[读]剑指offer

研二的开始找工作了，首先祝愿他们都能够找到自己满意的工作。看着他们的身影，自问明年自己这个时候是否可以从容面对呢？心虚不已，赶紧从老严那儿讨来一本《剑指offer》。在此顺便将自己做题所想，发现的一些小技巧记录于此，就当是学习笔记。先上一些，没做完的后面有时间继续补上。

2013.09.04于行政北楼

一.数组

题目1：二维数组的查找

在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成这样一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

例如下面的二维数组就是每行、每列都递增排序。如果在这个数组中查找数字7，则返回true；如果查找数字5，由于数组不含有该数字，则返回false；

1    2    8    9

2    4    9   12

4    7   10  13

6    8   11  15

思路：这题的关键点是用好“每一行从左到要递增，每一列从上到下递增”这个条件，解题时从数组右上角9出发，若它等于查找的数，那么返回结束；若它比查找数小，那么向左移动到8，继续查找；若它比查找数大，那么向下移动到12。比如说我们要寻找7，一次经过的数是9-8-2-4-7，返回。

 #include<iostream>
 using namespace std;

 const int row=;
 const int column=;

 bool Find(int array[][],int search_number)
 {
     bool result=false;
     int i=;
     int j=column-;
     int temp;//=array[i][j];

     while(i<=row&&j>=)
     {
         temp=array[i][j];
         if(search_number==temp)
         {
             result=true;
             break;
         }
         else if(search_number>temp)
             i++;
         else
             j--;
     }
     return result;
 }

 int main()
 {
     int array[][]={ {,,,},{,,,},{,,,},{,,,} };
     int search_number;
     for(search_number=;search_number<;search_number++)
     {
         if(Find(array,search_number))
             cout<<"查找"<<search_number<<"：Yes"<<endl;
         else
             cout<<"查找"<<search_number<<"：No"<<endl;
     }
     return ;
 }

 #include<iostream>
 using namespace std;

 const int row=;
 const int column=;

 bool Find(int array[][],int search_number)
 {
     bool result=false;
     int i=;
     int j=column-;
     int temp;//=array[i][j];

     while(i<=row&&j>=)
     {
         temp=array[i][j];
         if(search_number==temp)
         {
             result=true;
             break;
         }
         else if(search_number>temp)
             i++;
         else
             j--;
     }
     return result;
 }

 int main()
 {
     int array[][]={ {,,,},{,,,},{,,,},{,,,} };
     int search_number;
     for(search_number=;search_number<;search_number++)
     {
         if(Find(array,search_number))
             cout<<"查找"<<search_number<<"：Yes"<<endl;
         else
             cout<<"查找"<<search_number<<"：No"<<endl;
     }
     return ;
 }

题目2：数字在排序数组中出现的次数

统计一个数字在排序数组中出现的次数。例如输入排序数组{1,2,3,3,3,3,4,5}和数字3，由于3在这个数组中出现了4次，因此输出4.

思路：这一题很容易想到的方法是从头至尾遍历一遍数组，count++，非常简单，时间复杂度O(n)；但是既然数组是排序的，那么就有优化的空间，我们自然想到“二分搜索法”，先找到第一个3，然手是最后一个3，最后求出3出现了几次，这样的时间复杂度就为O(logn)。

 #include<iostream>
 using namespace std;

 /*二分搜索
 int BSearch(int a[],int left,int right,int search_number)
 {
     if(left<=right)
     {
         int middle=(left+right)/2;
         if(a[middle]<search_number) BSearch(a,middle+1,right,search_number);
         else if(a[middle]>search_number) BSearch(a,left,middle-1,search_number);
         else return middle;
     }
     return -1;//搜索失败
 }
 */

 int BSearch_first(int a[],int left,int right,int search_number)
 {
     if(left<=right)
     {
         int middle=(left+right)/;
         if(a[middle]<search_number) return BSearch_first(a,middle+,right,search_number);//return 一定要写，否则一定返回-1；
                                                                                          //本人纠结了好久才发现这个错误,泪。。
         else if(a[middle]==search_number)
         {
             if(a[middle-]==search_number) return BSearch_first(a,left,middle-,search_number);
             else return middle;
         }
         else return BSearch_first(a,left,middle-,search_number);
     }
     return -;
 }

 int BSearch_last(int a[],int left,int right,int search_number)
 {
     if(left<=right)
     {
         int middle=(left+right)/;
         if(a[middle]>search_number)  return BSearch_last(a,left,middle-,search_number);
         else if(a[middle]==search_number)
         {
             if(a[middle+]==search_number) return BSearch_last(a,middle+,right,search_number);
             else return middle;
         }
         else return BSearch_last(a,middle+,right,search_number);
     }
     return -;
 }

 /***************test
     a[]={1,2,3,3,3,3,4,5}
     a[]={3,3,3,3,4,5};
     a[]={1,2,3,3,3,3};
     a[]={1,3,3,3,3,4};
     a[]={3,3,3,3},3;
     a[]={3,3,3,3},2;
 ********************/
 int main()
 {
     int a[]={,,,};
     int first=BSearch_first(a,,,);//first:第一个3的位置
     int last=BSearch_last(a,,,);//last:最后一个3的位置
     int count=;
     if(first!=-&&last!=-)
         count=last-first+;
     cout<<first<<" "<<last<<" "<<count<<endl;
     return ;
 }

 #include<iostream>
 using namespace std;

 /*二分搜索
 int BSearch(int a[],int left,int right,int search_number)
 {
     if(left<=right)
     {
         int middle=(left+right)/2;
         if(a[middle]<search_number) BSearch(a,middle+1,right,search_number);
         else if(a[middle]>search_number) BSearch(a,left,middle-1,search_number);
         else return middle;
     }
     return -1;//搜索失败
 }
 */

 int BSearch_first(int a[],int left,int right,int search_number)
 {
     if(left<=right)
     {
         int middle=(left+right)/;
         if(a[middle]<search_number) return BSearch_first(a,middle+,right,search_number);//return 一定要写，否则一定返回-1；
                                                                                          //本人纠结了好久才发现这个错误,泪。。
         else if(a[middle]==search_number)
         {
             if(a[middle-]==search_number) return BSearch_first(a,left,middle-,search_number);
             else return middle;
         }
         else return BSearch_first(a,left,middle-,search_number);
     }
     return -;
 }

 int BSearch_last(int a[],int left,int right,int search_number)
 {
     if(left<=right)
     {
         int middle=(left+right)/;
         if(a[middle]>search_number)  return BSearch_last(a,left,middle-,search_number);
         else if(a[middle]==search_number)
         {
             if(a[middle+]==search_number) return BSearch_last(a,middle+,right,search_number);
             else return middle;
         }
         else return BSearch_last(a,middle+,right,search_number);
     }
     return -;
 }

 /***************test
     a[]={1,2,3,3,3,3,4,5}
     a[]={3,3,3,3,4,5};
     a[]={1,2,3,3,3,3};
     a[]={1,3,3,3,3,4};
     a[]={3,3,3,3},3;
     a[]={3,3,3,3},2;
 ********************/
 int main()
 {
     int a[]={,,,};
     int first=BSearch_first(a,,,);//first:第一个3的位置
     int last=BSearch_last(a,,,);//last:最后一个3的位置
     int count=;
     if(first!=-&&last!=-)
         count=last-first+;
     cout<<first<<" "<<last<<" "<<count<<endl;
     return ;
 }

题目3（*）：数组中只出现一次的数字

一个整型数组里除了两个数字之外，其他的数字都出现了两次。如{2,4,3,6,3,2,5,5,}，输出为4和6。请写出程序找出这两个只出现一次的数字。要求时间复杂度是O(n),空间复杂度是O(1)。

思路：初见这一题应该很容易联想到一个数组里面只有一个数字不同的时候应该怎么找出来。http://acm.njupt.edu.cn/acmhome/problemdetail.do?&method=showdetail&id=1057，方法就是异或运算。如还是对所有数异或，那么结果肯定是两个只出现一次的数字异或的结果（成对出现的异或抵消了），怎么通过这个结果找到两个只出现一次的数字呢？《剑指offer》给出了思路：如果能把原数组分成两个子数组，使得每个子数组包含一个只出现的数字，这样我们就能分别找出两个只出现一次的数字了。怎么分呢?读者可以自己先行思考。

 #include<iostream>
 using namespace std;

 #define length 9

 void find(int a[])
 {
     int i;
     int t=;//t记录两个单独数字异或值
     for(i=;i<length;i++)
         t^=a[i];
     int index=;//index记录t最低位为1的位置
     int x=t;
     while((x&)==)
     {
         x=x>>;
         ++index;
     }
     int m=;//记录index位为1的数字
     int n=;//记录index位为0的数字
     for(i=;i<length;i++)
     {
         int data=a[i]>>index;
         if(data&)//若为1，则与m最后值为1组
         {
             m^=a[i];
         }
         else//若为0，则与n最后值为1组
         {
             n^=a[i];
         }
     }
     cout<<m<<" "<<n<<endl;
 }

 int main()
 {
     int a[length]={,,,,,,,};
     find(a);
     return ;
 }

题目4：查找和排序

把一个数组最开始的若干元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。

   //二分搜索，复杂度O(logn)
   #include<iostream>
   using namespace std;

   #define length 5

   int minnum(int x,int y)
   {
       return x<y?x:y;
  }

  void minofarray(int a[],int n)
  {
      int i,j;
      i=;
      j=n-;
      int min=(i+j)/;

      while((j-i)>)
      {
          if(a[min]<a[j])
          {
              j=min;
              min=(i+min)/;
          }
          else
          {
              i=min;
              min=(min+j)/;
          }
      }
      cout<<minnum(a[i],a[j])<<endl;
  }

  int main()
  {
      int a[length]={,,,,};
      minofarray(a,length);
      return ;
  }

题目5：调整数组顺序使奇数位于偶数前面

应该很快联想到快速排序的思路，于是：

 void ReOrder(int a[],int length)
 {
     int i=-;
     int j=length;
     do{
         do i++;while(a[i]&);
         do j--;while(!(a[j]&));
         if(i<j) swap(a[i],a[j]);
     }while(i<j);
     for(i=;i<length;i++)
         cout<<a[i]<<" ";
     cout<<endl;
 }

但是，《剑指offer》指出：若把数组中的数按正负数分为两部分，再写一遍代码？若把数组中按能不能被3整除分为两部分，再写一遍代码？

所以，我们不是要解决一个问题，而是解决一类问题的通用方法。这就是面试官在考察我们对扩展性的理解，寄希望我们能够给出一个模式，在这个模式下能够很方便地把已有的解决方案扩展到同类型的问题上去。

这里，我们只要用一个判断函数来表示while语句的条件就可以了。

题目6：顺时针打印数组

没什么好说的，有兴趣的可以看着两题：

http://acm.njupt.edu.cn/acmhome/problemdetail.do?&method=showdetail&id=1094

http://acm.njupt.edu.cn/acmhome/problemdetail.do?&method=showdetail&id=1058

题目7：数组中出现次数超过一半的数字

数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，一次输出2。

方法1：遍历数组，count数组用来记录每个数字出现的次数，遍历count数组，若count[i]>length/2，输入对应数字。时间复杂度都为O(n²)，空间复杂度O(n)，这是最易想到的方法。

方法2：方法1复杂度为O(n²)，原因是又遍历了一遍count数组，因为不知道新的数字是否在count数组中出现过。既然这样，先排序，无需再遍历，中间的数即是，时间复杂度为O(nlogn)。

“最直观的算法通常不是面试官满意的算法”。

方法3：第k大数

方法4：遍历数组的时候保存两个值，一个是数组中的数字，一个是次数。当遍历到下一个数字的时候，如果下一个数字和我们之前保存的数字相同，则数字加1，若不同则减1.若次数为零，我们需要保存下一个数字，并把次数设为1。由于我们要找的数字出现的次数比其他所有数字出现的次数之和还要多，那么要找的数字肯定是最后把次数设为1时对应的数字。即不同数两两相消，剩下的数为出现次数最多的。

题目8：最小的k个数

输入n个整数，找出其中最小的k个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。

方法1：排序，前k个数。时间复杂度O(nlogn)。

方法2：因为题目要求最小k个，并不要求排好顺序，所以取k个数，记录最大的数max，继续遍历，若大于max，则替换，时间复杂度O(n)。

上述方法2，若不改变原始数组，需要额外O(k)的辅助空间。

看了书之后，发现自己方法2出现了错误，因为对于替换后的新数组，需要重新求得其最小值，这里可以用最小堆或者红黑树求得，那么复杂度应该是O(nlogk)。

题目9：连续子数组的最大和

输入一个整型数组，数组里有正数也有负数。数组中一个或连续的多个整数组成一个子数组。求所有子数组的和的最大值。要求时间复杂度为O(n)。

典型的动态规划题，但是时间复杂度是O(n²)，显然不符合题目要求，这里code顺便复习一下：

因为只有负数会减小结果，记录每次遇到负数时的sum，若为负数则抛弃，sum置零，继续相加，若下一次的sum大于max则替换，只需遍历一次数组，时间复杂度为O(n)。

题目10：把数组排成最小的数

输入一个正整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。例如输入数组{3,32,321}，则打印出这3个数字能排成的最小数字321323。

题目11：数组中的逆序对

在数组中的两个数字如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。

方法1：从第一个数开始，遍历后面每个数跟当前数比较，如果符合条件就加1，时间复杂度O(n²），显然不行。

方法2：归并排序

二.字符串

题目1：替换空格

请事先一个函数，把字符串中的每个空格替换成“20%"。例如输入”we are happy.“，则输出”we%20are%20happy.“。

思路：我们可以先遍历一次字符串，这样就能统计出字符串中空格的总数，并可以由此计算出替换之后的字符串的总长度。没替换一个空格，长度增加2。从字符串的后面开始复制和替换。首先准备两个指针，p1和p2。p1指向原始字符串的末尾，p2指向替换后的字符串的末尾。解析来向前移动p1，逐个复制到p2指向的位置，知道碰到空格位置。碰到空格后，p1向前移动1格，在p2之前插入字符串“%20”，同时p2向前移动3格。

上面算法的时间复杂度为O(n)，下面是代码：

 #include<iostream>
 using namespace std;

 const int length=;

 void ReplaceBlank(char str[])
 {
     int oldlength=strlen(str);
     int numofblank=;
     int i,j;

     for(i=;i<oldlength;i++)
     {
         if(str[i]==' ')
             numofblank++;
     }
     int newlength=oldlength+numofblank*;
     j=newlength;
     for(i=oldlength;i>=;i--)
     {
         if(str[i]!=' ')
         {
             str[j]=str[i];
             j--;
         }
         else
         {
             str[j--]='';
             str[j--]='';
             str[j--]='%';
         }
     }
 }

 int main()
 {
     char str[length];
     strcpy(str," we  are happy. ");
     ReplaceBlank(str);
     cout<<str<<endl;
     return ;
 }

  #include<iostream>
  using namespace std;

  const int length=;

  void ReplaceBlank(char str[])
  {
      int oldlength=strlen(str);
      int numofblank=;
     int i,j;

     for(i=;i<oldlength;i++)
     {
         if(str[i]==' ')
             numofblank++;
     }
     int newlength=oldlength+numofblank*;
     j=newlength;
     for(i=oldlength;i>=;i--)
     {
         if(str[i]!=' ')
         {
             str[j]=str[i];
             j--;
         }
         else
         {
             str[j--]='';
             str[j--]='';
             str[j--]='%';
         }
     }
 }

 int main()
 {
     char str[length];
     strcpy(str," we  are happy. ");
     ReplaceBlank(str);
     cout<<str<<endl;
     return ;
 }

附：有两个排序数组A1和A2，内存在A1的末尾有足够的空余空间容纳A2。请实现一个函数，把A2的所有数字插入到A1中并且所有的数字是排序的。

思考：如果从前往后复制每个数字需要移动数字多次，那么我们可以从后往前复制，这样就能该减少移动的次数，从而提高效率。

 #include<iostream>
 using namespace std;

 #define maxsize 100

 void merge(int array1[],int array2[])
 {
     int length1=;
     int length2=;
     int length=length1+length2;
     int i=length1-;
     int j=length2-;
     int k=length-;
     while(i>-&&j>-)
     {
         if(array1[i]>array2[j])
         {
             array1[k]=array1[i];
             i--;
             k--;
         }
         else
         {
             array1[k]=array2[j];
             j--;
             k--;
         }
     }
     if(j>-)
     {
         for(k=;k<=j;k++)
             array1[k]=array2[k];
     }
     for(i=;i<length;i++)
         cout<<array1[i]<<" ";
     cout<<endl;
 }

 int main()
 {
     //测试用例
     int array1[maxsize]={,,,,,};
     int array2[]={,,,,,,};
     merge(array1,array2);
     return ;
 }

 #include<iostream>
  using namespace std;

  #define maxsize 100

  void merge(int array1[],int array2[])
  {
      int length1=;
      int length2=;
     int length=length1+length2;
     int i=length1-;
     int j=length2-;
     int k=length-;
     while(i>-&&j>-)
     {
         if(array1[i]>array2[j])
         {
             array1[k]=array1[i];
             i--;
             k--;
         }
         else
         {
             array1[k]=array2[j];
             j--;
             k--;
         }
     }
     if(j>-)
     {
         for(k=;k<=j;k++)
             array1[k]=array2[k];
     }
     for(i=;i<length;i++)
         cout<<array1[i]<<" ";
     cout<<endl;
 }

 int main()
 {
     //测试用例
     int array1[maxsize]={,,,,,};
     int array2[]={,,,,,,};
     merge(array1,array2);
     return ;
 }

上述方法时间复杂度为O(m+n),如果你觉得还有更好的方法，或者此程序还有不足之处，欢迎跟我联系交流！

题目2：翻转单词顺序

输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。为了简单起见，标点符号和普通字母一样处理。例如输入字符串“I am a student."，则输出"student. a am I"。

 #include<iostream>
 #include<string>
 using namespace std;

 void swap(char &a,char &b)
 {
     char c;
     c=a;
     a=b;
     b=c;
 }

 void reverse(string &str)
 {
     int length=str.length();
     int i,j;
     for(i=;i<length/;i++)//翻转整个句子
         swap(str[i],str[length-i-]);
     int temp=-;
     for(i=;i<=length;i++)//翻转每个单词
     {
         if(str[i]==' '||str[i]=='\0')
         {
             cout<<""<<endl;
             for(j=temp+;j<(i+temp+)/;j++)
                 swap(str[j],str[i-j+temp]);
             temp=i;
         }
     }
 }

 int main()
 {
     string str="I am a student.";
     reverse(str);
     cout<<str<<endl;
     return ;
 }

附：字符串的左旋转操作时吧字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如输入字符串”abcdefg“和数字2，该函数将返回左旋转2位得到的结果”cdefgab“。

 #include<iostream>
 #include<string>
 using namespace std;

 void swap(char &a,char &b)
 {
     char c;
     c=a;
     a=b;
     b=c;
 }

 void reverse(string &str,int m)
 {
     int length=str.length();
     int n=length-m-;
     int i;
     for(i=;i<length/;i++)
         swap(str[i],str[length-i-]);
     for(i=;i<n/;i++)
         swap(str[i],str[n-i]);
     for(i=n+;i<(length+n+)/;i++)
         swap(str[i],str[length-i+n]);
 }

 int main()
 {
     string str="abcdefg";
     int m=;
     reverse(str,);
     cout<<str<<endl;
     return ;
 }

题目3：字符串的排列

输入一个字符串，打印出该字符串中字符的所有排列。例如输入字符串abc，则打印出有字符a、b、c所能排列出来的所有字符串abc、acb、bac、bca、cab和cba。

考查全排列，可以直接用STL中的next_permutation函数，下面是另外一题。

http://acm.njupt.edu.cn/acmhome/problemdetail.do?&method=showdetail&id=1103

题目4：第一个只出现一次的字符

在字符串中找出第一个只出现一次的字符。如输入“abaccdeff”，则输出‘b'。

遍历两次，第一次count数组记录每个字符出现的次数，第二次遍历输出第一个count等于1的字符。这里最好用hashtable。

三.链表

题目1：从尾到头打印链表

输入一个链表的头结点，从尾到头反过来打印出每个结点的值。

链表的定义如下：

struct ListNode

{

int            m_nKey;

ListNode* m_pNext;

};

 #include <iostream>
 using namespace std;

 struct ListNode
 {
     int m_nKey;
     ListNode* m_pNext;
 };

 void PrintListReverse(ListNode* pHead)
 {
     if(pHead!=NULL)
     {
         if(pHead->m_pNext!=NULL)
         {
             PrintListReverse(pHead->m_pNext);
         }
         cout<<pHead->m_nKey<<" ";
     }
 }

 ListNode* CreateListNode(int key)
 {
     ListNode* pNode=new ListNode();
     pNode->m_nKey=key;
     pNode->m_pNext=NULL;
     return pNode;
 }

 void ConnectListNodes(ListNode *pNode1,ListNode *pNode2)
 {
     pNode1->m_pNext=pNode2;
 }

 void DestroyList(ListNode *pHead)
 {
     pHead=NULL;
 }

 void Test(ListNode *pHead)
 {
     PrintListReverse(pHead);
 }

 void Test1()
 {
     cout<<"Test1 begins:"<<endl;

     ListNode* pNode1 = CreateListNode();
     ListNode* pNode2 = CreateListNode();
     ListNode* pNode3 = CreateListNode();
     ListNode* pNode4 = CreateListNode();
     ListNode* pNode5 = CreateListNode();

     ConnectListNodes(pNode1, pNode2);
     ConnectListNodes(pNode2, pNode3);
     ConnectListNodes(pNode3, pNode4);
     ConnectListNodes(pNode4, pNode5);

     Test(pNode1);
     cout<<endl;

     DestroyList(pNode1);
 }

 void Test2()
 {
     cout<<"Test2 begins:"<<endl;
     ListNode* pNode1 = CreateListNode();
     Test(pNode1);
     cout<<endl;
     DestroyList(pNode1);
 }

 void Test3()
 {
     cout<<"Test3 begins:"<<endl;
     Test(NULL);
 }

 int main()
 {
     Test1();
     Test2();
     Test3();
     return ;
 }

  #include <iostream>
  using namespace std;

  struct ListNode
  {
      int m_nKey;
      ListNode* m_pNext;
  };

 void PrintListReverse(ListNode* pHead)
 {
     if(pHead!=NULL)
     {
         if(pHead->m_pNext!=NULL)
         {
             PrintListReverse(pHead->m_pNext);
         }
         cout<<pHead->m_nKey<<" ";
     }
 }

 ListNode* CreateListNode(int key)
 {
     ListNode* pNode=new ListNode();
     pNode->m_nKey=key;
     pNode->m_pNext=NULL;
     return pNode;
 }

 void ConnectListNodes(ListNode *pNode1,ListNode *pNode2)
 {
     pNode1->m_pNext=pNode2;
 }

 void DestroyList(ListNode *pHead)
 {
     pHead=NULL;
 }

 void Test(ListNode *pHead)
 {
     PrintListReverse(pHead);
 }

 void Test1()
 {
     cout<<"Test1 begins:"<<endl;

     ListNode* pNode1 = CreateListNode();
     ListNode* pNode2 = CreateListNode();
     ListNode* pNode3 = CreateListNode();
     ListNode* pNode4 = CreateListNode();
     ListNode* pNode5 = CreateListNode();

     ConnectListNodes(pNode1, pNode2);
     ConnectListNodes(pNode2, pNode3);
     ConnectListNodes(pNode3, pNode4);
     ConnectListNodes(pNode4, pNode5);

     Test(pNode1);
     cout<<endl;

     DestroyList(pNode1);
 }

 void Test2()
 {
     cout<<"Test2 begins:"<<endl;
     ListNode* pNode1 = CreateListNode();
     Test(pNode1);
     cout<<endl;
     DestroyList(pNode1);
 }

 void Test3()
 {
     cout<<"Test3 begins:"<<endl;
     Test(NULL);
 }

 int main()
 {
     Test1();
     Test2();
     Test3();
     return ;
 }

题目2：在O(1)时间删除链表接点

给定单项链表的头指针和一个结点指针，定义一个函数在O(1)时间删除该结点。

思路：若是从头结点开始遍历寻找该删除结点p，那么时间复杂度肯定是O(n)，那么自然想到从删除结点p入手，因为结点p有一个指向下一个结点的指针next，我们将p的值赋给下一个指针，删除结点p即可。（注意考虑代码完整性：链表只有一个结点，删除尾结点，删除普通结点）

题目3：链表中倒数第k个结点

我的思路还是两个指针i，j指向头结点，i先向后遍历，当i指向第k个结点时，j开始移动，i指向尾结点的时候，那么j指向的结点就是倒数第k个结点。

但是存在3个问题（鲁棒性）：

(1)输入的pListNode为空指针。试图访问空指针的内存，程序崩溃。

(2)输入的以pListNode为头结点的结点数少于k。循环k-1次，仍然会指向空指针。

(3)输入参数为0。由于k是一个无符号整数，那么在for循环中k-1得到的将不是-1，而是4294967295(0xFFFFFFFF)，同样也会造成程序崩溃。

题目4：反转链表

思路很简单，原链表的3个结点p->q->r，q->next=q(不能写反了);p=q;q=r;

题目5：合并两个排序的链表

 ListNode *Merge(ListNode *pHead1，ListNode *pHead2)
 {
     if(pHead1==NULL) return pHead2;
     if(pHead2==NULL) return pHead1;
     ListNode *pHead=NULL;
     if(pHead1->value<pHead2->value)
     {
         pHead=pHead1;
         pHead->next=Merge(pHead1->next,pHead2);
     }
     else
     {
         pHead=pHead2;
         pHead->next=Merge(pHead1,pHead2->next);
     }
     return pHead;
 }

题目6：复杂链表的复制 

      请实现函数ComplexListNode *Clone(ComplexListNode *pHead)，复制一个复杂链表。在复杂 链表中，每个节点除了有一个m_pNext指针指向下一个结点外，还有一个m_pSibling指向链表中的任意结点或者NULL。

题目7：两个链表的第一个公共结点

输入两个链表，找出他们的第一个公共结点。

给两个指针i，j分别从两个表头开始遍历，找到相同的结点遍历结束。其实我错了亮点：第一，key相同的不一定是同一个结点；第二，两个链表不一定一样长，一起遍历，因为可能会错开相同的结点，不一定能够找到。比如：

上图中红2不是公共结点，红5才是。因为公共结点后的key都是相同的，所以正确的做法是：先遍历两个链表，得到表长length1，length2，这里假设length1>length2。重新遍历，指针i先走（length1-length2）步，然后i，j一起前进，遇到相同key，记录结点pNode，继续遍历，若后续结点不同，则pNode置空，继续遍历，直到遍历结束，返回pNode。

四.树

二叉树结点的定义如下：

struct BinaryTreeNode

{

int  m_nValue;

BinaryTreeNode *m_pLeft;

BinaryTreeNode *m_pRight;

};

题目1：重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含有重复的数字。

题目2：数的子结构

输入两棵二叉树A和B，判断B是不是A的子结构。

题目3：二叉树的镜像

请完成一个函数，输入一个二叉树，该函数输出它的镜像。

题目4：从上往下打印二叉树

题目5:二叉搜索树的后续遍历序列

题目6：二叉树中和为某一值的路径

题目7：二叉搜索树与双向链表

题目8：二叉树的深度

五.栈和队列

题目1：用两个栈实现队列

用两个栈实现一个队列。队列的声明如下，请实现它的两个函数appendTail和deleteHead，分别完成在队列尾部插入结点和在队列头部删除结点的功能。

template<typename T> class CQueue

{

public:

CQueue(void);

~CQueue(void);

void appendTail(const T& node);

T deleteHead();

private:

stack<T> stack1;

stack<T> stack2;

};

 #include <iostream>
 #include <stack>
 using namespace std;

 template <class T>
 class CQueue
 {
 public:
     CQueue(void){};
     ~CQueue(void){};

     void appendTail(const T& node);
     T deleteHead();

 private:
     stack<T> stack1;
     stack<T> stack2;
 };

 template <class T>
 void CQueue<T>::appendTail(const T& node)
 {
     stack1.push(node);
 }

 template <class T>
 T CQueue<T>::deleteHead()
 {
     while(!stack1.empty())
     {
         T temp=stack1.top();
         stack1.pop();
         stack2.push(temp);
     }
     if(stack2.empty())
         throw new exception("queue is empty");
     T head=stack2.top();
     stack2.pop();
     return head;
 }

 int main()
 {
     CQueue<int> queue;
     queue.appendTail();
     queue.appendTail();
     queue.appendTail();
     cout<<queue.deleteHead()<<endl;
     cout<<queue.deleteHead()<<endl;
     cout<<queue.deleteHead()<<endl;
     return ;
 }

 #include <iostream>
  #include <stack>
  using namespace std;

  template <class T>
  class CQueue
  {
  public:
      CQueue(void){};
     ~CQueue(void){};

     void appendTail(const T& node);
     T deleteHead();

 private:
     stack<T> stack1;
     stack<T> stack2;
 };

 template <class T>
 void CQueue<T>::appendTail(const T& node)
 {
     stack1.push(node);
 }

 template <class T>
 T CQueue<T>::deleteHead()
 {
     while(!stack1.empty())
     {
         T temp=stack1.top();
         stack1.pop();
         stack2.push(temp);
     }
     if(stack2.empty())
         throw new exception("queue is empty");
     T head=stack2.top();
     stack2.pop();
     return head;
 }

 int main()
 {
     CQueue<int> queue;
     queue.appendTail();
     queue.appendTail();
     queue.appendTail();
     cout<<queue.deleteHead()<<endl;
     cout<<queue.deleteHead()<<endl;
     cout<<queue.deleteHead()<<endl;
     return ;
 }

题目2：包含min函数的栈

题目3：栈的压入、弹出序列

六.其他

题目1：从1到n整数中1出现的次数

输入一个整数n，求从1到n这n个整数的十进制表示中1出现的次数。例如输入12，从1到12这些证书中包含1的数字有1,10,11,和12,1一共出现了5次。

题目2：丑数

题目3：和为s的两个数字VS和为s的连续正数序列

题目4：n个骰子的点数

题目5：扑克牌的顺子

题目6：圆桌最后剩下的数字

题目7：求1+2+...+n

题目8：不能被继承的类