15道使用频率极高的基础算法题：

1、合并排序，将两个已经排序的数组合并成一个数组，其中一个数组能容下两个数组的所有元素;
2、合并两个已经排序的单链表;
3、倒序打印一个单链表;
4、给定一个单链表的头指针和一个指定节点的指针，在O(1)时间删除该节点;
5、找到链表倒数第K个节点;
6、反转单链表;
7、通过两个栈实现一个队列;
8、二分查找;
9、快速排序;
10、获得一个int型的数中二进制中的个数;
11、输入一个数组，实现一个函数，让所有奇数都在偶数前面;
12、判断一个字符串是否是另一个字符串的子串;
13、把一个int型数组中的数字拼成一个串，这个串代表的数字最小;
14、输入一颗二叉树，输出它的镜像（每个节点的左右子节点交换位置）;
15、输入两个链表，找到它们第一个公共节点;

代码实现：

1. //链表节点
   
2. struct NodeL
   
3. {
   
4.     int value;
   
5.     NodeL* next;
   
6.     NodeL(int value_=0,NodeL* next_=NULL):value(value_),next(next_){}
   
7. };
   
8. //二叉树节点
   
9. struct NodeT
   
10. {
    
11.     int value;
    
12.     NodeT* left;
    
13.     NodeT* right;
    
14.     NodeT(int value_=0,NodeT* left_=NULL,NodeT* right_=NULL):value(value_),left(left_),right(right_){}
    
15. };

复制代码

1、合并排序，将两个已经排序的数组合并成一个数组，其中一个数组能容下两个数组的所有元素;

合并排序一般的思路都是创建一个更大数组C，刚好容纳两个数组的元素，先是一个while循环比较，将其中一个数组A比较完成，将另一个数组B中所有的小于前一个数组A的数及A中所有的数按顺序存入C中，再将A中剩下的数存入C中，但这里是已经有一个数组能存下两个数组的全部元素，就不用在创建数组了，但只能从后往前面存，从前往后存，要移动元素很麻烦。

1. //合并排序，将两个已经排序的数组合并成一个数组，其中一个数组能容下两个数组的所有元素
   
2. void MergeArray(int a[],int alen,int b[],int blen)
   
3. {
   
4.     int len=alen+blen-1;
   
5.     alen--;
   
6.     blen--;
   
7.     while (alen>=0 && blen>=0)
   
8.     {
   
9.         if (a[alen]>b[blen])
   
10.         {
    
11.             a[len--]=a[alen--];
    
12.         }else{
    
13.             a[len--]=b[blen--];
    
14.         }
    
15.     }
    
16. 
    
17.     while (alen>=0)
    
18.     {
    
19.         a[len--]=a[alen--];
    
20.     }
    
21.     while (blen>=0)
    
22.     {
    
23.         a[len--]=b[blen--];
    
24.     }
    
25. }
    
26. 
    
27. void MergeArrayTest()
    
28. {
    
29.     int a[]={2,4,6,8,10,0,0,0,0,0};
    
30.     int b[]={1,3,5,7,9};
    
31.     MergeArray(a,5,b,5);
    
32.     for (int i=0;i<sizeof(a)/sizeof(a[0]);i++)
    
33.     {
    
34.         cout<<a[i]<<" ";
    
35.     }
    
36. }

复制代码

2、合并两个单链表;

合并链表和合并数组，我用了大致相同的代码，就不多少了，那本书用的是递归实现。

1. //链表节点
   
2. struct NodeL
   
3. {
   
4.     int value;
   
5.     NodeL* next;
   
6.     NodeL(int value_=0,NodeL* next_=NULL):value(value_),next(next_){}
   
7. };
   
8. 
   
9. //合并两个单链表
   
10. NodeL* MergeList(NodeL* head1,NodeL* head2)
    
11. {
    
12.     if (head1==NULL)
    
13.         return head2;
    
14.     if (head2==NULL)
    
15.         return head1;
    
16. 
    
17.     NodeL* head=NULL;
    
18.     if (head1->value<head2->value)
    
19.     {
    
20.         head=head1;
    
21.         head1=head1->next;
    
22.     }else{
    
23.         head=head2;
    
24.         head2=head2->next;
    
25.     }
    
26.     NodeL* tmpNode=head;
    
27.     while (head1 && head2)
    
28.     {
    
29.         if (head1->value<head2->value)
    
30.         {
    
31.             head->next=head1;
    
32.             head1=head1->next;
    
33.         }else{
    
34.             head->next=head2;
    
35.             head2=head2->next;
    
36.         }
    
37.         head=head->next;
    
38.     }
    
39.     if (head1)
    
40.     {
    
41.         head->next=head1;
    
42.     }
    
43.     if (head2)
    
44.     {
    
45.         head->next=head2;
    
46.     }
    
47.     return tmpNode;
    
48. }
    
49. 
    
50. void MergeListTest()
    
51. {
    
52.     NodeL* head1=new NodeL(1);
    
53.     NodeL* cur=head1;
    
54.     for (int i=3;i<10;i+=2)
    
55.     {
    
56.         NodeL* tmpNode=new NodeL(i);
    
57.         cur->next=tmpNode;
    
58.         cur=tmpNode;
    
59.     }
    
60.     NodeL* head2=new NodeL(2);
    
61.     cur=head2;
    
62.     for (int i=4;i<10;i+=2)
    
63.     {
    
64.         NodeL* tmpNode=new NodeL(i);
    
65.         cur->next=tmpNode;
    
66.         cur=tmpNode;
    
67.     }
    
68.     NodeL* head=MergeList(head1,head2);
    
69.     while (head)
    
70.     {
    
71.         cout<<head->value<<" ";
    
72.         head=head->next;
    
73.     }
    
74. }

复制代码

3、倒序打印一个单链表;

递归实现，先递归在打印就变成倒序打印了，如果先打印在调用自己就是顺序打印了。

1. //倒序打印一个单链表
   
2. void ReversePrintNode(NodeL* head)
   
3. {
   
4.     if (head)
   
5.     {
   
6.         ReversePrintNode(head->next);
   
7.         cout<<head->value<<endl;
   
8.     }
   
9. }
   
10. void ReversePrintNodeTest()
    
11. {
    
12.     NodeL* head=new NodeL();
    
13.     NodeL* cur=head;
    
14.     for (int i=1;i<10;i++)
    
15.     {
    
16.         NodeL* tmpNode=new NodeL(i);
    
17.         cur->next=tmpNode;
    
18.         cur=tmpNode;
    
19.     }
    
20.     ReversePrintNode(head);
    
21. }

复制代码

4、给定一个单链表的头指针和一个指定节点的指针，在O(1)时间删除该节点;

删除节点的核心还是将这个节点的下一个节点，代替当前节点。

1. //给定一个单链表的头指针和一个指定节点的指针，在O(1)时间删除该节点
   
2. void DeleteNode(NodeL* head,NodeL* delNode)
   
3. {
   
4.     if (!head || !delNode)
   
5.     {
   
6.         return;
   
7.     }
   
8. 
   
9.     if (delNode->next!=NULL)//删除中间节点
   
10.     {
    
11.         NodeL* next=delNode->next;
    
12.         delNode->next=next->next;
    
13.         delNode->value=next->value;
    
14.         delete next;
    
15.         next=NULL;
    
16.     }else if (head==delNode)//删除头结点
    
17.     {
    
18.         delete delNode;
    
19.         delNode=NULL;
    
20.         *head=NULL;
    
21.     }else//删除尾节点，考虑到delNode不在head所在的链表上的情况
    
22.     {
    
23.         NodeL* tmpNode=head;
    
24.         while (tmpNode && tmpNode->next!=delNode)
    
25.         {
    
26.             tmpNode=tmpNode->next;
    
27.         }
    
28.         if (tmpNode!=NULL)
    
29.         {
    
30.             delete delNode;
    
31.             delNode=NULL;
    
32.             tmpNode->next=NULL;
    
33.         }
    
34.     }
    
35. }
    
36. 
    
37. void DeleteNodeTest()
    
38. {
    
39.     int nodeCount=10;
    
40.     for (int K=0;K<nodeCount;K++)
    
41.     {
    
42.         NodeL* head=NULL;
    
43.         NodeL* cur=NULL;
    
44.         NodeL* delNode=NULL;
    
45.         for (int i=0;i<nodeCount;i++)
    
46.         {
    
47.             NodeL* tmpNode=new NodeL(i);
    
48.             if (i==0)
    
49.             {
    
50.                 cur=head=tmpNode;
    
51.             }else{
    
52.                 cur->next=tmpNode;
    
53.                 cur=tmpNode;
    
54.             }
    
55.             if (i==K)
    
56.             {
    
57.                 delNode=tmpNode;
    
58.             }
    
59.         }
    
60.         DeleteNode(head,delNode) ;
    
61.     }
    
62. }

复制代码

5、找到链表倒数第K个节点;

通过两个指针，两个指针都指向链表的开始，一个指针先向前走K个节点，然后再以前向前走，当先走的那个节点到达末尾时，另一个节点就刚好与末尾节点相差K个节点。

1. //找到链表倒数第K个节点
   
2. NodeL* FindKthToTail(NodeL* head,unsigned int k)
   
3. {
   
4.     if(head==NULL || k==0)
   
5.         return NULL;
   
6.     NodeL* tmpNode=head;
   
7.     for (int i=0;i<k;i++)
   
8.     {
   
9.         if (tmpNode!=NULL)
   
10.         {
    
11.             tmpNode=tmpNode->next;
    
12.         }else{
    
13.             return NULL;
    
14.         }
    
15.     }
    
16.     NodeL* kNode=head;
    
17.     while (tmpNode!=NULL)
    
18.     {
    
19.         kNode=kNode->next;
    
20.         tmpNode=tmpNode->next;
    
21.     }
    
22.     return kNode;
    
23. }
    
24. 
    
25. void FindKthToTailTest()
    
26. {
    
27.     int nodeCount=10;
    
28.     for (int K=0;K<nodeCount;K++)
    
29.     {
    
30.         NodeL* head=NULL;
    
31.         NodeL* cur=NULL;
    
32.         for (int i=0;i<nodeCount;i++)
    
33.         {
    
34.             NodeL* tmpNode=new NodeL(i);
    
35.             if (i==0)
    
36.             {
    
37.                 cur=head=tmpNode;
    
38.             }else{
    
39.                 cur->next=tmpNode;
    
40.                 cur=tmpNode;  
    
41.             }
    
42.         }
    
43.         NodeL* kNode=FindKthToTail(head,K+3) ;
    
44.         if (kNode)
    
45.         {
    
46.             cout<<"倒数第 "<<K+3<<" 个节点是："<<kNode->value<<endl;
    
47.         }else{
    
48.             cout<<"倒数第 "<<K+3<<" 个节点不在链表中" <<endl;
    
49.         }
    
50.     }
    
51. }

复制代码

6、反转单链表;

按顺序一个个的翻转就是了。

1. //反转单链表
   
2. NodeL* ReverseList(NodeL* head)
   
3. {
   
4.     if (head==NULL)
   
5.     {
   
6.         return NULL;
   
7.     }
   
8.     NodeL* reverseHead=NULL;
   
9.     NodeL* curNode=head;
   
10.     NodeL* preNode=NULL;
    
11.     while (curNode!=NULL)
    
12.     {
    
13.         NodeL* nextNode=curNode->next;
    
14.         if (nextNode==NULL)
    
15.             reverseHead=curNode;  
    
16. 
    
17.         curNode->next=preNode;
    
18.         preNode=curNode;
    
19.         curNode=nextNode;
    
20.     }
    
21.     return reverseHead;
    
22. }
    
23. 
    
24. void ReverseListTest()
    
25. {
    
26.     for (int K=0;K<=10;K++)
    
27.     {
    
28.         NodeL* head=NULL;
    
29.         NodeL* cur=NULL;
    
30.         for (int i=0;i<K;i++)
    
31.         {
    
32.             NodeL* tmpNode=new NodeL(i);
    
33.             if (i==0)
    
34.             {
    
35.                 cur=head=tmpNode;
    
36.             }else{
    
37.                 cur->next=tmpNode;
    
38.                 cur=tmpNode;  
    
39.             }
    
40.         }
    
41. 
    
42.         cur=ReverseList( head);
    
43.         while (cur)
    
44.         {
    
45.             cout<<cur->value<<" ";
    
46.             cur=cur->next;
    
47.         }
    
48.         cout<<endl;
    
49.     }
    
50.     cout<<endl;
    
51. }

复制代码

7、通过两个栈实现一个队列;

直接上代码

1. //通过两个栈实现一个队列
   
2. template<typename T>
   
3. class CQueue
   
4. {
   
5. public:
   
6.     void push(const T& val)
   
7.     {
   
8.         while (s2.size()>0)
   
9.         {
   
10.             s1.push(s2.top());
    
11.             s2.pop();
    
12.         }
    
13.         s1.push(val);
    
14.     }
    
15.     void pop()
    
16.     {
    
17.         while (s1.size()>0)
    
18.         {
    
19.             s2.push(s1.top());
    
20.             s1.pop();
    
21.         }
    
22.         s2.pop();
    
23.     }
    
24. 
    
25.     T& front()
    
26.     {
    
27.         while (s1.size()>0)
    
28.         {
    
29.             s2.push(s1.top());
    
30.             s1.pop();
    
31.         }
    
32.         return s2.top();
    
33.     }
    
34.     int size()
    
35.     {
    
36.         return s1.size()+s2.size();
    
37.     }
    
38. private:
    
39.     stack<T> s1;
    
40.     stack<T> s2;
    
41. };
    
42. 
    
43. void CQueueTest()
    
44. {
    
45.     CQueue<int> q;
    
46.     for (int i=0;i<10;i++)
    
47.     {
    
48.         q.push(i);
    
49.     }
    
50.     while (q.size()>0)
    
51.     {
    
52.         cout<<q.front()<<" ";
    
53.         q.pop();
    
54.     }
    
55. }

复制代码

8、二分查找;

二分查找记住几个要点就行了，代码也就那几行，反正我现在是可以背出来了，start=0，end=数组长度-1，while(start<=end)，注意溢出。

1. //二分查找
   
2. int binarySearch(int a[],int len,int val)
   
3. {
   
4.     int start=0;
   
5.     int end=len-1;
   
6.     int index=-1;
   
7.     while (start<=end)
   
8.     {
   
9.         index=start+(end-start)/2;
   
10.         if (a[index]==val)
    
11.         {
    
12.             return index;
    
13.         }else if (a[index]<val)
    
14.         {
    
15.             start=index+1;
    
16.         }else
    
17.         {
    
18.             end=index-1;
    
19.         }
    
20.     }
    
21.     return -1;
    
22. }

复制代码

9、快速排序;

来自百度百科，说不清楚

1. //快速排序
   
2. //之前有个面试叫我写快排，想都没想写了个冒泡,思路早忘了，这段代码来自百度百科
   
3. void Qsort(int a[],int low,int high)
   
4. {
   
5.     if(low>=high)
   
6.     {
   
7.         return;
   
8.     }
   
9.     int first=low;
   
10.     int last=high;
    
11.     int key=a[first];//用字表的第一个记录作为枢轴
    
12.     while(first<last)
    
13.     {
    
14.         while(first<last && a[last]>=key )--last;
    
15.         a[first]=a[last];//将比第一个小的移到低端
    
16.         while(first<last && a[first]<=key )++first;
    
17.         a[last]=a[first];//将比第一个大的移到高端
    
18.     }
    
19.     a[first]=key;//枢轴记录到位
    
20.     Qsort(a,low,first-1);
    
21.     Qsort(a,last+1,high);
    
22. }
    
23. 
    
24. void QsortTest()
    
25. {
    
26.     int a[]={1,3,5,7,9,2,4,6,8,0};
    
27.     int len=sizeof(a)/sizeof(a[0])-1;
    
28.     Qsort(a,0,len);
    
29.     for(int i=0;i<=len;i++)
    
30.     {
    
31.         cout<<a[i]<<" ";
    
32.     }
    
33.     cout<<endl;
    
34. }

复制代码

10、获得一个int型的数中二进制中的个数;

核心实现就是while (num= num & (num-1))，通过这个数和比它小1的数的二进制进行&运算，将二进制中1慢慢的从后往前去掉，直到没有。

1. //获得一个int型的数中二进制中1的个数
   
2. int Find1Count(int num)
   
3. {
   
4.     if (num==0)
   
5.     {
   
6.         return 0;
   
7.     }
   
8.     int count=1;
   
9.     while (num= num & (num-1))
   
10.     {
    
11.         count++;
    
12.     }
    
13.     return count;
    
14. }

复制代码

11、输入一个数组，实现一个函数，让所有奇数都在偶数前面;

两个指针，一个从前往后，一个从后往前，前面的指针遇到奇数就往后走，后面的指针遇到偶数就往前走，只要两个指针没有相遇，就奇偶交换。

1. //输入一个数组，实现一个函数，让所有奇数都在偶数前面
   
2. void RecordOddEven(int A[],int len)
   
3. {
   
4.     int i=0,j=len-1;
   
5.     while (i<j)
   
6.     {
   
7.         while (i<len && A[i]%2==1)
   
8.             i++;
   
9. 
   
10.         while (j>=0 && A[j]%2==0)
    
11.             j--;
    
12. 
    
13.         if (i<j)
    
14.         {
    
15.             A[i]^=A[j]^=A[i]^=A[j];
    
16.         }
    
17.     }
    
18. }
    
19. 
    
20. void RecordOddEvenTest()
    
21. {
    
22.     int A[]={1,2,3,4,5,6,7,8,9,0,11};
    
23.     int len=sizeof(A)/sizeof(A[0]);
    
24.     RecordOddEven( A , len);
    
25.     for (int i=0;i<len;i++)
    
26.     {
    
27.         cout<<A[i]<<" ";
    
28.     }
    
29.     cout<<endl;
    
30.     for (int i=0;i<len;i++)
    
31.     {
    
32.         A[i]=2;
    
33.     }
    
34.     RecordOddEven( A , len);
    
35.     for (int i=0;i<len;i++)
    
36.     {
    
37.         cout<<A[i]<<" ";
    
38.     }
    
39.     cout<<endl;
    
40.     for (int i=0;i<len;i++)
    
41.     {
    
42.         A[i]=1;
    
43.     }
    
44.     RecordOddEven( A , len);
    
45.     for (int i=0;i<len;i++)
    
46.     {
    
47.         cout<<A[i]<<" ";
    
48.     }
    
49. }

复制代码

12、判断一个字符串是否是另一个字符串的子串;

我这里就是暴力的对比

1. //判断一个字符串是否是另一个字符串的子串
   
2. int substr(const char* source,const char* sub)
   
3. {
   
4.     if (source==NULL || sub==NULL)
   
5.     {
   
6.         return -1;
   
7.     }
   
8.     int souLen=strlen(source);
   
9.     int subLen=strlen(sub);
   
10.     if (souLen<subLen)
    
11.     {
    
12.         return -1;
    
13.     }
    
14. 
    
15.     int cmpCount=souLen-subLen;
    
16.     for (int i=0;i<=cmpCount;i++)
    
17.     {
    
18.         int j=0;
    
19.         for (;j<subLen;j++)
    
20.         {
    
21.             if (source[i+j]!=sub[j])
    
22.             {
    
23.                 break;
    
24.             }
    
25.         }
    
26.         if (j==subLen)
    
27.         {
    
28.             return i ;
    
29.         }
    
30.     }
    
31.     return -1;
    
32. }

复制代码

13、把一个int型数组中的数字拼成一个串，这个串代表的数字最小;

先将数字转换成字符串存在数组中，在通过qsort排序，在排序用到的比较函数中，将要比较的两个字符串进行组合，如要比较的两个字符串分别是A,B，那么组合成，A+B，和B+A，在比较A+B和B+A，返回strcmp(A+B, B+A)，经过qsort这么一排序,数组就变成从小到大的顺序了，组成的数自然是最小的。

1. //把一个int型数组中的数字拼成一个串，是这个串代表的数组最小
   
2. #define MaxLen 10
   
3. int Compare(const void* str1,const void* str2)
   
4. {
   
5.     char cmp1[MaxLen*2+1];
   
6.     char cmp2[MaxLen*2+1];
   
7.     strcpy(cmp1,*(char**)str1);
   
8.     strcat(cmp1,*(char**)str2);
   
9. 
   
10.     strcpy(cmp2,*(char**)str2);
    
11.     strcat(cmp2,*(char**)str1);
    
12.     return strcmp(cmp1,cmp2);
    
13. }  
    
14. void GetLinkMin(int a[],int len)
    
15. {
    
16.     char** str=(char**)new int[len];
    
17.     for (int i=0;i<len;i++)
    
18.     {
    
19.         str[i]=new char[MaxLen+1];
    
20.         sprintf(str[i],"%d",a[i]);
    
21.     }
    
22. 
    
23.     qsort(str,len,sizeof(char*),Compare);
    
24.     for (int i=0;i<len;i++)
    
25.     {
    
26.         cout<<str[i]<<" ";
    
27.         delete[] str[i] ;
    
28.     }
    
29.     delete[] str;
    
30. }
    
31. void GetLinkMinTest()
    
32. {
    
33.     int arr[]={123,132,213,231,321,312};
    
34.     GetLinkMin(arr,sizeof(arr)/sizeof(int));
    
35. }

复制代码

14、输入一颗二叉树，输出它的镜像（每个节点的左右子节点交换位置）;

递归实现，只要某个节点的两个子节点都不为空，就左右交换，让左子树交换，让右子树交换。

1. struct NodeT
   
2. {
   
3.     int value;
   
4.     NodeT* left;
   
5.     NodeT* right;
   
6.     NodeT(int value_=0,NodeT* left_=NULL,NodeT* right_=NULL):value(value_),left(left_),right(right_){}
   
7. };
   
8. 
   
9. //输入一颗二叉树，输出它的镜像（每个节点的左右子节点交换位置）
   
10. void TreeClass(NodeT* root)
    
11. {
    
12.     if( root==NULL || (root->left==NULL && root->right==NULL) )
    
13.         return;
    
14.     NodeT* tmpNode=root->left;
    
15.     root->left=root->right;
    
16.     root->right=tmpNode;
    
17.     TreeClass(root->left);
    
18.     TreeClass(root->right);
    
19. }
    
20. 
    
21. void PrintTree(NodeT* root)
    
22. {
    
23.     if(root)
    
24.     {
    
25.         cout<<root->value<<" ";
    
26.         PrintTree(root->left);
    
27.         PrintTree(root->right);
    
28.     }
    
29. }
    
30. 
    
31. void TreeClassTest()
    
32. {
    
33.     NodeT* root=new NodeT(8);
    
34.     NodeT* n1=new NodeT(6);
    
35.     NodeT* n2=new NodeT(10);
    
36.     NodeT* n3=new NodeT(5);
    
37.     NodeT* n4=new NodeT(7);
    
38.     NodeT* n5=new NodeT(9);
    
39.     NodeT* n6=new NodeT(11);
    
40.     root->left=n1;
    
41.     root->right=n2;
    
42.     n1->left=n3;
    
43.     n1->right=n4;
    
44.     n2->left=n5;
    
45.     n2->right=n6;
    
46.     PrintTree(root);
    
47.     cout<<endl;
    
48.     TreeClass( root );
    
49.     PrintTree(root);
    
50.     cout<<endl;
    
51. }

复制代码

15、输入两个链表，找到它们第一个公共节点;

如果两个链表有公共的节点，那么第一个公共的节点及往后的节点都是公共的。从后往前数N个节点（N=短链表的长度节点个数）,长链表先往前走K个节点（K=长链表的节点个数-N），这时两个链表都距离末尾N个节点，现在可以一一比较了，最多比较N次，如果有两个节点相同就是第一个公共节点，否则就没有公共节点。

1. //输入两个链表，找到它们第一个公共节点
   
2. int GetLinkLength(NodeL* head)
   
3. {
   
4.     int count=0;
   
5.     while (head)
   
6.     {
   
7.         head=head->next;
   
8.         count++;
   
9.     }
   
10.     return count;
    
11. }
    
12. 
    
13. NodeL* FindFirstEqualNode(NodeL* head1,NodeL* head2)
    
14. {
    
15.     if (head1==NULL || head2==NULL)
    
16.         return NULL;
    
17.     int len1=GetLinkLength(head1);
    
18.     int len2=GetLinkLength(head2);
    
19.     NodeL* longNode;
    
20.     NodeL* shortNode;
    
21.     int leftNodeCount;
    
22.     if (len1>len2)
    
23.     {
    
24.         longNode=head1;
    
25.         shortNode=head2;
    
26.         leftNodeCount=len1-len2;
    
27.     }else{
    
28.         longNode=head2;
    
29.         shortNode=head1;
    
30.         leftNodeCount=len2-len1;
    
31.     }
    
32.     for (int i=0;i<leftNodeCount;i++)
    
33.     {
    
34.         longNode=longNode->next;
    
35.     }
    
36.     while (longNode && shortNode && longNode!=shortNode)
    
37.     {
    
38.         longNode=longNode->next;
    
39.         shortNode=shortNode->next;
    
40.     }
    
41.     if (longNode)//如果有公共节点，必不为NULL
    
42.     {
    
43.         return longNode;
    
44.     }
    
45.     return NULL;  
    
46. }
    
47. 
    
48. void FindFirstEqualNodeTest()
    
49. {
    
50.     NodeL* head1=new NodeL(0);
    
51.     NodeL* head2=new NodeL(0);
    
52.     NodeL* node1=new NodeL(1);
    
53.     NodeL* node2=new NodeL(2);
    
54.     NodeL* node3=new NodeL(3);
    
55.     NodeL* node4=new NodeL(4);
    
56.     NodeL* node5=new NodeL(5);
    
57.     NodeL* node6=new NodeL(6);
    
58.     NodeL* node7=new NodeL(7);
    
59. 
    
60.     head1->next=node1;
    
61.     node1->next=node2;
    
62.     node2->next=node3;
    
63.     node3->next=node6;//两个链表相交于节点node6
    
64. 
    
65.     head2->next=node4;
    
66.     node4->next=node5;
    
67.     node5->next=node6;//两个链表相交于节点node6
    
68.     node6->next=node7;
    
69. 
    
70.     NodeL* node= FindFirstEqualNode(head1,head2);
    
71.     if (node)
    
72.     {
    
73.         cout<<node->value<<endl;
    
74.     }else{
    
75.         cout<<"没有共同节点"<<endl;
    
76.     }
    
77. }
    

复制代码

不明觉厉!

立姐又传授经验那，非常感谢呢，我一定会好好收藏的，赶紧努力进黑马啊

收藏，谢谢

好厉害的总结

嗯嗯，挺好不错。可以好好学习学习

不明觉厉

虽然现在看不懂，但是以后一定要懂哇。

很给力啊

上课无聊，，，无聊的课，看立姐的

好东西先收藏了, 慢慢研究

给力啊，虽然有些还不会 ，先收藏起来

先收着啦。。。

这个....先收藏了

谢谢楼主，这东西很有用

不错已收藏

感谢分享，学习看看

这么好的分享，不收藏岂不是亏了！

果断分享

学习了~~~