15个算法题目

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

　　2:合并两个单链表;

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

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

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

　　6:反转单链表;

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

　　8:二分查找;

　　9:快速排序;

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

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

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

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

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

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

　　下面简单说说思路和代码实现。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

//链表节点 struct NodeL {     int value;     NodeL* next;     NodeL(int value_=0,NodeL* next_=NULL):value(value_),next(next_){} }; //二叉树节点 struct NodeT {     int value;     NodeT* left;     NodeT* right;     NodeT(int value_=0,NodeT* left_=NULL,NodeT* right_=NULL):value(value_),left(left_),right(right_){} };

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

//合并排序，将两个已经排序的数组合并成一个数组，其中一个数组能容下两个数组的所有元素 void MergeArray(int a[],int alen,int b[],int blen) {     int len=alen+blen-1;     alen--;     blen--;     while (alen>=0 && blen>=0)     {         if (a[alen]>b[blen])         {             a[len--]=a[alen--];         }else{             a[len--]=b[blen--];         }     }       while (alen>=0)     {         a[len--]=a[alen--];     }     while (blen>=0)     {         a[len--]=b[blen--];     } }   void MergeArrayTest() {     int a[]={2,4,6,8,10,0,0,0,0,0};     int b[]={1,3,5,7,9};     MergeArray(a,5,b,5);     for (int i=0;i<sizeof(a)/sizeof(a[0]);i++)     {         cout<<a[i]<<" ";     } }

　　2:合并两个单链表;

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74

//链表节点 struct NodeL {     int value;     NodeL* next;     NodeL(int value_=0,NodeL* next_=NULL):value(value_),next(next_){} };   //合并两个单链表 NodeL* MergeList(NodeL* head1,NodeL* head2) {     if (head1==NULL)         return head2;     if (head2==NULL)         return head1;       NodeL* head=NULL;     if (head1->value<head2->value)     {         head=head1;         head1=head1->next;     }else{         head=head2;         head2=head2->next;     }     NodeL* tmpNode=head;     while (head1 && head2)     {         if (head1->value<head2->value)         {             head->next=head1;             head1=head1->next;         }else{             head->next=head2;             head2=head2->next;         }         head=head->next;     }     if (head1)     {         head->next=head1;     }     if (head2)     {         head->next=head2;     }     return tmpNode; }   void MergeListTest() {     NodeL* head1=new NodeL(1);     NodeL* cur=head1;     for (int i=3;i<10;i+=2)     {         NodeL* tmpNode=new NodeL(i);         cur->next=tmpNode;         cur=tmpNode;     }     NodeL* head2=new NodeL(2);     cur=head2;     for (int i=4;i<10;i+=2)     {         NodeL* tmpNode=new NodeL(i);         cur->next=tmpNode;         cur=tmpNode;     }     NodeL* head=MergeList(head1,head2);     while (head)     {         cout<<head->value<<" ";         head=head->next;     } }

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

//倒序打印一个单链表 void ReversePrintNode(NodeL* head) {     if (head)     {         ReversePrintNode(head->next);         cout<<head->value<<endl;     } } void ReversePrintNodeTest() {     NodeL* head=new NodeL();     NodeL* cur=head;     for (int i=1;i<10;i++)     {         NodeL* tmpNode=new NodeL(i);         cur->next=tmpNode;         cur=tmpNode;     }     ReversePrintNode(head); }

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

//给定一个单链表的头指针和一个指定节点的指针，在O(1)时间删除该节点 void DeleteNode(NodeL* head,NodeL* delNode) {     if (!head || !delNode)     {         return;     }       if (delNode->next!=NULL)//删除中间节点     {         NodeL* next=delNode->next;         delNode->next=next->next;         delNode->value=next->value;         delete next;         next=NULL;     }else if (head==delNode)//删除头结点     {         delete delNode;         delNode=NULL;         *head=NULL;     }else//删除尾节点，考虑到delNode不在head所在的链表上的情况     {         NodeL* tmpNode=head;         while (tmpNode && tmpNode->next!=delNode)         {             tmpNode=tmpNode->next;         }         if (tmpNode!=NULL)         {             delete delNode;             delNode=NULL;             tmpNode->next=NULL;         }     } }   void DeleteNodeTest() {     int nodeCount=10;     for (int K=0;K<nodeCount;K++)     {         NodeL* head=NULL;         NodeL* cur=NULL;         NodeL* delNode=NULL;         for (int i=0;i<nodeCount;i++)         {             NodeL* tmpNode=new NodeL(i);             if (i==0)             {                 cur=head=tmpNode;             }else{                 cur->next=tmpNode;                 cur=tmpNode;             }             if (i==K)             {                 delNode=tmpNode;             }         }         DeleteNode(head,delNode) ;     } }

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

//找到链表倒数第K个节点 NodeL* FindKthToTail(NodeL* head,unsigned int k) {     if(head==NULL || k==0)         return NULL;     NodeL* tmpNode=head;     for (int i=0;i<k;i++)     {         if (tmpNode!=NULL)         {             tmpNode=tmpNode->next;         }else{             return NULL;         }     }     NodeL* kNode=head;     while (tmpNode!=NULL)     {         kNode=kNode->next;         tmpNode=tmpNode->next;     }     return kNode; }   void FindKthToTailTest() {     int nodeCount=10;     for (int K=0;K<nodeCount;K++)     {         NodeL* head=NULL;         NodeL* cur=NULL;         for (int i=0;i<nodeCount;i++)         {             NodeL* tmpNode=new NodeL(i);             if (i==0)             {                 cur=head=tmpNode;             }else{                 cur->next=tmpNode;                 cur=tmpNode;              }         }         NodeL* kNode=FindKthToTail(head,K+3) ;         if (kNode)         {             cout<<"倒数第 "<<K+3<<" 个节点是："<<kNode->value<<endl;         }else{             cout<<"倒数第 "<<K+3<<" 个节点不在链表中" <<endl;         }     } }

　　6:反转单链表;

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

//反转单链表 NodeL* ReverseList(NodeL* head) {     if (head==NULL)     {         return NULL;     }     NodeL* reverseHead=NULL;     NodeL* curNode=head;     NodeL* preNode=NULL;     while (curNode!=NULL)     {         NodeL* nextNode=curNode->next;         if (nextNode==NULL)             reverseHead=curNode;            curNode->next=preNode;         preNode=curNode;         curNode=nextNode;     }     return reverseHead; }   void ReverseListTest() {     for (int K=0;K<=10;K++)     {         NodeL* head=NULL;         NodeL* cur=NULL;         for (int i=0;i<K;i++)         {             NodeL* tmpNode=new NodeL(i);             if (i==0)             {                 cur=head=tmpNode;             }else{                 cur->next=tmpNode;                 cur=tmpNode;              }         }           cur=ReverseList( head);         while (cur)         {             cout<<cur->value<<" ";             cur=cur->next;         }         cout<<endl;     }     cout<<endl; }

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

　　直接上代码

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

//通过两个栈实现一个队列 template<typename T> class CQueue { public:     void push(const T& val)     {         while (s2.size()>0)         {             s1.push(s2.top());             s2.pop();         }         s1.push(val);     }     void pop()     {         while (s1.size()>0)         {             s2.push(s1.top());             s1.pop();         }         s2.pop();     }       T& front()     {         while (s1.size()>0)         {             s2.push(s1.top());             s1.pop();         }         return s2.top();     }     int size()     {         return s1.size()+s2.size();     } private:     stack<T> s1;     stack<T> s2; };   void CQueueTest() {     CQueue<int> q;     for (int i=0;i<10;i++)     {         q.push(i);     }     while (q.size()>0)     {         cout<<q.front()<<" ";         q.pop();     } }

　　8:二分查找;

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

//二分查找 int binarySearch(int a[],int len,int val) {     int start=0;     int end=len-1;     int index=-1;     while (start<=end)     {         index=start+(end-start)/2;         if (a[index]==val)         {             return index;         }else if (a[index]<val)         {             start=index+1;         }else         {             end=index-1;         }     }     return -1; }

　　9:快速排序;

　　来自百度百科，说不清楚

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

//快速排序 //之前有个面试叫我写快排，想都没想写了个冒泡,思路早忘了，这段代码来自百度百科 void Qsort(int a[],int low,int high) {     if(low>=high)     {         return;     }     int first=low;     int last=high;     int key=a[first];//用字表的第一个记录作为枢轴     while(first<last)     {         while(first<last && a[last]>=key )--last;         a[first]=a[last];//将比第一个小的移到低端         while(first<last && a[first]<=key )++first;         a[last]=a[first];//将比第一个大的移到高端     }     a[first]=key;//枢轴记录到位     Qsort(a,low,first-1);     Qsort(a,last+1,high); }   void QsortTest() {     int a[]={1,3,5,7,9,2,4,6,8,0};     int len=sizeof(a)/sizeof(a[0])-1;     Qsort(a,0,len);     for(int i=0;i<=len;i++)     {         cout<<a[i]<<" ";     }     cout<<endl; }

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14

//获得一个int型的数中二进制中1的个数 int Find1Count(int num) {     if (num==0)     {         return 0;     }     int count=1;     while (num= num & (num-1))     {         count++;     }     return count; }

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

//输入一个数组，实现一个函数，让所有奇数都在偶数前面 void RecordOddEven(int A[],int len) {     int i=0,j=len-1;     while (i<j)     {         while (i<len && A[i]%2==1)             i++;           while (j>=0 && A[j]%2==0)             j--;           if (i<j)         {             A[i]^=A[j]^=A[i]^=A[j];         }     } }   void RecordOddEvenTest() {     int A[]={1,2,3,4,5,6,7,8,9,0,11};     int len=sizeof(A)/sizeof(A[0]);     RecordOddEven( A , len);     for (int i=0;i<len;i++)     {         cout<<A[i]<<" ";     }     cout<<endl;     for (int i=0;i<len;i++)     {         A[i]=2;     }     RecordOddEven( A , len);     for (int i=0;i<len;i++)     {         cout<<A[i]<<" ";     }     cout<<endl;     for (int i=0;i<len;i++)     {         A[i]=1;     }     RecordOddEven( A , len);     for (int i=0;i<len;i++)     {         cout<<A[i]<<" ";     } }

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

　　我这里就是暴力的对比

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

//判断一个字符串是否是另一个字符串的子串 int substr(const char* source,const char* sub) {     if (source==NULL || sub==NULL)     {         return -1;     }     int souLen=strlen(source);     int subLen=strlen(sub);     if (souLen<subLen)     {         return -1;     }       int cmpCount=souLen-subLen;     for (int i=0;i<=cmpCount;i++)     {         int j=0;         for (;j<subLen;j++)         {             if (source[i+j]!=sub[j])             {                 break;             }         }         if (j==subLen)         {             return i ;         }     }     return -1; }

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

//把一个int型数组中的数字拼成一个串，是这个串代表的数组最小 #define MaxLen 10 int Compare(const void* str1,const void* str2) {     char cmp1[MaxLen*2+1];     char cmp2[MaxLen*2+1];     strcpy(cmp1,*(char**)str1);     strcat(cmp1,*(char**)str2);       strcpy(cmp2,*(char**)str2);     strcat(cmp2,*(char**)str1);     return strcmp(cmp1,cmp2); }  void GetLinkMin(int a[],int len) {     char** str=(char**)new int[len];     for (int i=0;i<len;i++)     {         str[i]=new char[MaxLen+1];         sprintf(str[i],"%d",a[i]);     }       qsort(str,len,sizeof(char*),Compare);     for (int i=0;i<len;i++)     {         cout<<str[i]<<" ";         delete[] str[i] ;     }     delete[] str; } void GetLinkMinTest() {     int arr[]={123,132,213,231,321,312};     GetLinkMin(arr,sizeof(arr)/sizeof(int)); }

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

struct NodeT {     int value;     NodeT* left;     NodeT* right;     NodeT(int value_=0,NodeT* left_=NULL,NodeT* right_=NULL):value(value_),left(left_),right(right_){} };   //输入一颗二叉树，输出它的镜像（每个节点的左右子节点交换位置） void TreeClass(NodeT* root) {     if( root==NULL || (root->left==NULL && root->right==NULL) )         return;     NodeT* tmpNode=root->left;     root->left=root->right;     root->right=tmpNode;     TreeClass(root->left);     TreeClass(root->right); }   void PrintTree(NodeT* root) {     if(root)     {         cout<<root->value<<" ";         PrintTree(root->left);         PrintTree(root->right);     } }   void TreeClassTest() {     NodeT* root=new NodeT(8);     NodeT* n1=new NodeT(6);     NodeT* n2=new NodeT(10);     NodeT* n3=new NodeT(5);     NodeT* n4=new NodeT(7);     NodeT* n5=new NodeT(9);     NodeT* n6=new NodeT(11);     root->left=n1;     root->right=n2;     n1->left=n3;     n1->right=n4;     n2->left=n5;     n2->right=n6;     PrintTree(root);     cout<<endl;     TreeClass( root );     PrintTree(root);     cout<<endl; }

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

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77

//输入两个链表，找到它们第一个公共节点 int GetLinkLength(NodeL* head) {     int count=0;     while (head)     {         head=head->next;         count++;     }     return count; }   NodeL* FindFirstEqualNode(NodeL* head1,NodeL* head2) {     if (head1==NULL || head2==NULL)         return NULL;     int len1=GetLinkLength(head1);     int len2=GetLinkLength(head2);     NodeL* longNode;     NodeL* shortNode;     int leftNodeCount;     if (len1>len2)     {         longNode=head1;         shortNode=head2;         leftNodeCount=len1-len2;     }else{         longNode=head2;         shortNode=head1;         leftNodeCount=len2-len1;     }     for (int i=0;i<leftNodeCount;i++)     {         longNode=longNode->next;     }     while (longNode && shortNode && longNode!=shortNode)     {         longNode=longNode->next;         shortNode=shortNode->next;     }     if (longNode)//如果有公共节点，必不为NULL     {         return longNode;     }     return NULL;  }   void FindFirstEqualNodeTest() {     NodeL* head1=new NodeL(0);     NodeL* head2=new NodeL(0);     NodeL* node1=new NodeL(1);     NodeL* node2=new NodeL(2);     NodeL* node3=new NodeL(3);     NodeL* node4=new NodeL(4);     NodeL* node5=new NodeL(5);     NodeL* node6=new NodeL(6);     NodeL* node7=new NodeL(7);       head1->next=node1;     node1->next=node2;     node2->next=node3;     node3->next=node6;//两个链表相交于节点node6       head2->next=node4;     node4->next=node5;     node5->next=node6;//两个链表相交于节点node6     node6->next=node7;       NodeL* node= FindFirstEqualNode(head1,head2);     if (node)     {         cout<<node->value<<endl;     }else{         cout<<"没有共同节点"<<endl;     } }