每天进步一点点之算法（一）

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

2:合并两个单链表;

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

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

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

6:反转单链表;

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

8:二分查找;

9:快速排序;

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

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

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

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

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

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

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

C

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中，但这里是已经有一个数组能存下两个数组的全部元素，就不用在创建数组了，但只能从后往前面存，从前往后存，要移动元素很麻烦。

2:合并两个单链表;

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

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 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:倒序打印一个单链表;

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

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

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

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 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个节点。

6:反转单链表;

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

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 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:通过两个栈实现一个队列;

直接上代码

8:二分查找;

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

C++

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