单链表的冒泡，快排，选择，插入，归并等多图详解

数据结构 前端之家
前端之家收集整理的这篇文章主要介绍了单链表的冒泡，快排，选择，插入，归并等多图详解，前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。

上节介绍了链表的基本操作

目录

这节介绍链表的5种排序算法。
@
目录

0.稳定排序和原地排序的定义

稳定排序：
  假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，ri=rj，且ri在rj之前，而在排序后的序列中，ri仍在rj之前，则称这种排序算法是稳定的；否则称为不稳定的。像冒泡排序，插入排序，基数排序，归并排序等都是稳定排序
原地排序：
  基本上不需要额外辅助的的空间，允许少量额外的辅助变量进行的排序。就是在原来的排序数组中比较和交换的排序。像选择排序，插入排序，希尔排序，快速排序，堆排序等都会有一项比较且交换操作(swap(i,j))的逻辑在其中，因此他们都是属于原地(原址、就地)排序，而合并排序，计数排序，基数排序等不是原地排序

1.冒泡排序

基本思想:
  把第一个元素与第二个元素比较，如果第一个比第二个大，则交换他们的位置。接着继续比较第二个与第三个元素，如果第二个比第三个大，则交换他们的位置....
  我们对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样一趟比较交换下来之后，排在最右的元素就会
是最大的数。除去最右的元素，我们对剩余的元素做同样的工作，如此重复下去，直到排序完成。
具体步骤：
  1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
  2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
  3.针对所有的元素重复以上的步骤，除了最后一个。
  4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
时间复杂度：O(N2)
空间复杂度：O(1)
稳定排序:是
原地排序:是

在这里插入图片描述

  2. Node *BubbleSort(Node *phead)
  3. {
  5. 	Node * p = phead;
  6. 	Node * q = phead->next;
  7. 	/*有几个数据就-1；比如x 个i<x-1*/
  8. 	for(int i=0;i<5;i++)
  9. 	{ 
  10. 		while((q!=NULL)&&(p!=NULL))
  11. 		{ 
  12. 			if(p->data>q->data)
  13. 			{
  14. 				/*头结点和下一节点的交换，要特殊处理，更新新的头head*/
  15. 				if (p == phead)
  16. 				{
  17. 					p->next = q->next;
  18. 					q->next = p;
  19. 					head = q;
  20. 					phead = q;
  21. 					/*这里切记要把p,q换回来，正常的话q应该在p的前面，进行的是p,q的比较
  22. 					*但是经过指针域交换之后就变成q,p.再次进行下一次比较时，
  23. 					*就会变成q,p的数据域比较。假如原本p->data > q->data,则进行交换。变成q->data和p->data比较，
  24. 					*不会进行交换，所以排序就会错误。有兴趣的可以调试下。
  25. 					*/	
  26. 					Node*temp=p; 
  27. 					p=q;
  28. 					q=temp;		
  29. 				}
  30. 				/*处理中间过程，其他数据的交换情况，要寻找前驱节点if (p != phead)*/
  31. 				else 
  32. 				{
  33. 					/*p，q的那个在前，那个在后。指针域的连接画图好理解一点*/
  34. 					if (p->next == q)
  35. 					{
  36. 						/*寻找p的前驱节点*/
  37. 						Node *ppre = FindPreNode(p);
  38. 						/*将p的下一个指向q的下一个*/
  39. 						p->next = q->next;
  40. 						/*此时q为头结点，让q的下一个指向p，连接起来*/
  41. 						q->next = p;
  42. 						/*将原来p的前驱节点指向现在的q，现在的q为头结点*/
  43. 						ppre->next = q;
  44. 						Node*temp=p; 
  45. 						p=q; 
  46. 						q=temp;
  47. 					}
  48. 					else if (q->next == p)
  49. 					{
  50. 						Node *qpre = FindPreNode(q);
  51. 						q->next = p->next;
  52. 						p->next = q;
  53. 						qpre->next = p;
  54. 						Node*temp=p;
  55. 						p=q; 
  56. 						q=temp;
  57. 						}									
  58. 				}		
  59. 			}
  60. 			/*地址移动*/
  61. 			p = p->next;
  62. 			q = q->next;
  63. 		}
  64. 		/*进行完一轮比较后，从头开始进行第二轮*/
  65. 		p = phead;
  66. 		q = phead->next;	
  67. 	}
  68. 	
  69. 	head = phead;
  70. 	return head;
  71. }

2.快速排序

基本思想
  我们从数组中选择一个元素，我们把这个元素称之为中轴元素吧，然后把数组中所有小于中轴元素的元素放在其左边，
所有大于或等于中轴元素的元素放在其右边，显然，此时中轴元素所处的位置的是有序的。也就是说，我们无需再移动中轴
元素的位置。
  从中轴元素那里开始把大的数组切割成两个小的数组(两个数组都不包含中轴元素)，接着我们通过递归的方式，让中轴元素
左边的数组和右边的数组也重复同样的操作，直到数组的大小为1，此时每个元素都处于有序的位置。
具体步骤：
  1.从数列中挑出一个元素，称为 "基准"（pivot）;
  2.重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
  3.递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；
时间复杂度：O(NlogN)
空间复杂度：O(logN)
稳定排序：否
原地排序：是

在这里插入图片描述

  2. int *QuickSort(Node* pBegin,Node* pEnd)
  3. {
  4.     if(pBegin == NULL || pEnd == NULL || pBegin == pEnd)
  5.         return 0;
  6.  
  7.     //定义两个指针
  8.     Node* p1 = pBegin;
  9.     Node* p2 = pBegin->next;
  10.     int pivot = pBegin->data;
  12. 	//每次只比较小的，把小的放在前面。经过一轮比较后，被分成左右两部分。其中p1指向中值处，pbegin为pivot。
  13.     while(p2 != NULL)/* && p2 != pEnd->next */
  14. 	{
  15.         if(p2->data < pivot)
  16. 		{
  17.             p1 = p1->next;
  18.             if(p1 != p2)
  19. 			{
  20.                 SwapData(&p1->data,&p2->data);
  21.         	}
  22.       	}
  23.         p2 = p2->next;
  24.    }
  25.    /*此时pivot并不在中间，我们要把他放到中间，以他为基准，把数据分为左右两边*/
  26.     SwapData(&p1->data,&pBegin->data);
  27.     //此时p1是中值节点
  28. 	//if(p1->data >pBegin->data)
  29.     QuickSort(pBegin,p1);
  30. 	//if(p1->data < pEnd->data)
  31.     QuickSort(p1->next,pEnd);
  33. }

3.插入排序

基本思想:每一步将一个待排序的记录，插入到前面已经排好序的有序序列中去，直到插完所有元素为止。
具体步骤：
  1.将待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列；
  2.取出下一个元素，在已经排序的元素序列中从后向前扫描；
  3.如果该元素（已排序）大于新元素，将该元素移到下一位置；
  4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
  5.将新元素插入到该位置后；
  6.重复步骤2~5。
时间复杂度：O(N2)
空间复杂度：O(1)
稳定排序：是
原地排序：是

在这里插入图片描述

  1. /*不好理解可以调试下看下具体过程*/
  2. Node *InsertSort(Node *phead)  
  3. {  
  4. 	/*为原链表剩下用于直接插入排序的节点头指针*/  
  5.     Node *unsort; 
  6. 	/*临时指针变量：插入节点*/
  7.     Node *t;  
  8. 	/*临时指针变量*/  
  9.     Node *p; 
  10. 	/*临时指针变量*/  
  11.     Node *sort; 
  12. 	/*原链表剩下用于直接插入排序的节点链表：可根据图12来理解。*/  
  13.     unsort = phead->next; 
  14. 	/*只含有一个节点的链表的有序链表：可根据图11来理解。*/  
  15.     head->next = NULL; 
  16.   	/*遍历剩下无序的链表*/ 
  17.     while (unsort != NULL)  
  18.     {  
  19.         /*注意：这里for语句就是体现直接插入排序思想的地方*/
  20. 		/*无序节点在有序链表中找插入的位置*/  
  21. 		/*跳出for循环的条件：
  22. 		*1.sort为空，此时，sort->data < t->data，p存下位置，应该放在有序链表的后面
  23. 		*2.sort->data > t->data ，跳出循环时，t->data放在有序链表sort的前面
  24. 		*3.sort为空 sort->data > t->data，也插入在sort前面的位置
  25. 		*/  
  26. 		/*q为有序链表*/
  27.         for (t = unsort,sort = phead; ((sort != NULL) && (sort->data < t->data)); p = sort,sort = sort->next); 
  28.       
  29.    		 /*退出for循环，就是找到了插入的位置插入位置要么在前面，要么在后面*/  
  30.     	/*注意：按道理来说，这句话可以放到下面注释了的那个位置也应该对的，但是就是不能。原因：你若理解了上面的第3条，就知道了。*/  
  31.        /*无序链表中的第一个节点离开，以便它插入到有序链表中。*/
  32. 	    unsort = unsort->next;    
  33. 		/*插在第一个节点之前*/ 
  34. 		/*sort->data > t->data*/
  35. 		/*sort为空 sort->data > t->data*/
  36.         if (sort == phead)  
  37.         {  
  38. 			/*整个无序链表给phead*/
  39.             phead = t;  
  40.         }  
  41. 		/*p是sort的前驱，这样说不太确切，当sort到最后时，for里面有个sort = sort->next，
  42. 		*就会把sort置空，所以要用p暂存上一次sort的值。而且执行判断sort->data < t->data时，用的也是上一次的sort
  43. 		*/
  44. 		/*sort后面插入*/
  45. 		/*sort遍历到了最后，此时，sort->data < t->data,sort和p都为最后一个元素。*/ 
  46.         else  
  47.         {  
  48.             p->next = t;  
  49.         }  
  50. 		/*if处理之后，t为无序链表，因为要在phead前插入。这里先把t赋值给phead，再把t的next指向sort，
  51. 		*就完成了在sort之前插入小的元素，很巧妙的一种方法
  52. 		*else处理完之后，sort存放的是sort的下一次，真正的sort存放在p中。不满足条件跳出循环时，判断的是下一次的sort，
  53. 		但是我们要用的插入的位置为上一次的sort，所以要记录下sort上一次的位置
  54. 		*/
  55. 		/*完成插入动作*/
  56. 		/*当sort遍历完成为空时，t->next就是断开后面的元素（sort为空）*/
  57. 		/*当sort不为空时，sort->data > t->data，sort存放的元素比t要大，放在后面，t->next就是再链接起来sort*/
  58.         t->next = sort;   
  59.         /*unsort = unsort->next;*/  
  60.     }  
  61. 	head = phead;
  62.     return phead;  
  63. }

4.选择排序

基本思想：首先，找到数组中最小的那个元素，其次，将它和数组的第一个元素交换位置(如果第一个元素就是最小元素那么它就和自己交换)。其次，在剩下的元素中找到最小的元素，将它与数组的第二个元素交换位置。如此往复，直到将整个数组排序。这种方法我们称之为选择排序。
具体步骤：
  1.首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
  2.再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
  3.重复第二步，直到所有元素均排序完毕。
时间复杂度：O(N2)
空间复杂度：O(1)
稳定排序：否
原地排序：是

在这里插入图片描述

  1. Node* SelectSort(Node* phead)                                                
  2. {                                                                                                             
  3. 	Node *temp;
  4. 	Node *temphead = phead;
  5. 	/*将第一次的最大值设置为头结点*/
  6. 	int max = phead->data;
  7. 	/*交换变量*/
  8. 	 for(int i = 0;i<LengthList(phead);i++)
  9. 	 {
  10. 		 /*每次遍历开始前都要把最大值设置为头结点*/
  11. 		  max = phead->data;
  12. 		while (temphead->next !=NULL)
  13. 		{
  14. 			/*寻找最大值*/
  15. 			if(max < temphead->next->data)
  16. 			{
  17. 				max =  temphead->next->data;
  18. 			}
  19. 			/*移动指针位置*/
  20. 			temphead = temphead->next;
  21. 		}	
  22. 		/*找到最大值的位置*/
  23. 		temp = FindList(max);
  24. 		/*判断最大值是否和头节点相同*/
  25. 		if(phead != temp)
  26. 		{
  27. 			SwapNode(phead,temp);		
  28. 		}
  29. 		/*更新下一次遍历的头结点*/
  30. 		temphead = temp->next;
  31. 		phead = temphead;
  32. 	 }
  34. }

  SwapNode相关代码如下。当时考虑只需要理解排序思想就好了，就没有把这个函数的代码放出来。这个代码写的太长太复杂了，有时间我会重新精简下。（说实话，我都快忘了怎么写的了）

  1. /*交换相邻节点*/
  2. void Swanext(Node *p,Node *q)
  3. {
  4. 	
  5. 	/*中间相邻节点*/
  6. 	if ((p != head)&&(q != head))
  7. 	{
  8. 		// /*p为前一个节点，q的前驱为p*/
  9. 		// /*寻找p的前驱结点*/
  10. 		// Node *ppre = FindPreNode(p);
  11. 		// Node *temp;
  12. 		
  13. 		// /*暂存p节点的后继结点，指向q*/
  14. 		// temp = p->next;
  15. 		// /*将q节点的后继节点赋值给p的后继结点，即将p节点放到了q位置（此时q的前驱节点的next指针还指向的是q）*/
  16. 		// p->next = q->next;
  17. 		// /*将p节点给q的next，即将完成了q与p的重新连接*/
  18. 		// q->next =p;
  19. 		// /*找到原来p的前驱节点，指向q，即完成了原来p的前驱结点和q节点的连接*/
  20. 		// ppre->next =q;
  21. 			if (p->next == q)
  22. 			{
  23. 				Node *ppre = FindPreNode(p);
  24. 				p->next = q->next;
  25. 				q->next = p;
  26. 				ppre->next = q;
  27. 				// PrintList(head);
  29. 			}
  30. 			else if (q->next == p)
  31. 			{
  32. 				Node *qpre = FindPreNode(q);
  33. 				q->next = p->next;
  34. 				p->next = q;
  35. 				qpre->next = p;
  37. 			}			
  39. 	}
  40. 	/*头结点相邻的交换*/	
  41. 	else
  42. 	{
  43. 		if(p == head)
  44. 		{
  45. 			p->next = q->next;
  46. 			q->next = p;
  47. 			head = q;
  48. 		}
  49. 		else 
  50. 		{
  51. 			q->next = p->next;
  52. 			p->next = q;	
  53. 			 head = p;		
  54. 		}
  55. 	}
  56. 	
  58. 	
  61. }
  62. /*交换头结点和任意节点(除尾节点外)*/
  63. void SwapHeadAnother(Node *tmphead,Node *p)
  64. {
  65. 	/*寻找p的前驱节点*/
  66. 	Node *ppre = FindPreNode(p);
  67. 	
  68. 	Node *temp;
  69. 	if(p!=tmphead->next)
  70. 	{
  71. 		/*暂存p节点*/
  72. 		temp = p->next;
  73. 		/*将tmphead节点的后继节点赋值给p的后继结点，即将tmphead节点放到了p位置（此时p的前驱节点的next指针还未断开）*/
  74. 		p->next = tmphead->next;
  75. 		/*将p的后继结点赋值给tmphead的后继结点，同时连接p的前驱和tmphead*/
  76. 		tmphead->next = temp;
  77. 		ppre->next =tmphead;
  78. 		/*新的头结点返回给全局head*/
  79. 		head = p;
  80. 	}
  82. 	else
  83. 	{
  84. 		/*头结点和下一节点*/
  85. 		 tmphead->next = p->next;
  86. 		 p->next = tmphead;
  87. 		 head = p;
  88. 	}
  91. 	
  93. }
  94. /*交换尾结点和任意节点(除头节点外)*/
  95. void SwapEndAnother(Node *tmpend,Node *p)
  96. {
  97. 	/*寻找p的前驱节点*/
  98. 	Node *ppre = FindPreNode(p);
  99. 	Node *endpre = FindPreNode(tmpend);
  100. 	Node *temp;
  101. 	if((tmpend==end)&&(p!=tmpend))
  102. 	{
  103. 		/*暂存p节点*/
  104. 		temp = p->next;
  105. 		/*将tmpend节点的后继节点赋值给p的后继结点，即将tmpend节点放到了p位置（此时p的前驱节点的next指针还未断开）*/
  106. 		p->next = tmpend->next;
  107. 		endpre->next = p;
  108. 		/*将p的后继结点赋值给tmpend的后继结点，同时连接p的前驱和tmpend（断开了之前的连接）*/
  109. 		tmpend->next = temp;
  110. 		ppre->next =tmpend;
  111. 		/*新的头结点返回给全局head*/
  112. 		end = p;
  113. 	}
  114. 	else
  115. 	{
  116. 		p->next = tmpend->next;
  117. 		tmpend->next = p;
  118. 		end = p;
  119. 	}
  121. 	
  123. }
  124. /*交换头结点和尾节点*/
  125. void SwapHeadEnd(Node *tmphead,Node *tmpend)
  126. {
  127. 	/*寻找tmpend的前驱节点*/
  128. 	Node *endpre = FindPreNode(tmpend);
  129. 	Node *temp;
  130. 	/*暂存tmpend节点*/
  131. 	temp = tmpend->next;
  132. 	/*将tmphead节点的后继节点赋值给tmpend的后继结点，即将tmpend节点放到了tmphead位置（此时tmpend的前驱节点的next指针还未断开）*/
  133. 	tmpend->next = tmphead->next;
  134. 	/*将p的后继结点赋值给tmpend的后继结点，同时连接p的前驱和tmpend（断开了之前的连接）*/
  135. 	tmphead->next = temp;
  136. 	endpre->next =tmphead;
  137. 	/*新的头结点返回给全局head*/
  138. 	head = tmpend;
  139. 	end = tmphead;
  140. 	// PrintList(tmpend);
  141. }
  143. void SwapRandom(Node *p,Node *q)
  144. {
  145. 	/*除了首尾节点，中间不相邻的两个节点*/
  146. 	
  147. 	if((p->next != q)||(q->next != p))
  148. 	{
  149. 		/*寻找前驱结点*/
  150. 		Node *ppre = FindPreNode(p);
  151. 		Node *qpre = FindPreNode(q);
  152. 		/*借助一个中间节点传递数据域*/
  153. 		Node *temp;
  154. 		temp = p->next;
  155. 		/*交换p和q*/
  156. 		/*2、p的新后继结点要变成q的原后继结点*/
  157. 		p->next = q->next;
  158. 		/*3、q的原前趋结点（qpre）的新后继结点要变成p*/
  159. 		qpre->next = p;
  160. 		/*4、q的新后继结点要变成p的原后继结点（p->next）*/
  161. 		q->next = temp;
  162. 		/*1、p的原前趋结点（ppre）的新后继结点要变成q*/
  163. 		ppre->next = q;
  164. 	}
  165. 	/*中间相邻节点的处理*/
  166. 	else if (p->next == q)
  167. 	{
  168. 		Node *ppre = FindPreNode(p);
  169. 		p->next = q->next;
  170. 		q->next = p;
  171. 		ppre->next = q;
  173. 	}
  174. 	else if (q->next == p)
  175. 	{
  176. 		Node *qpre = FindPreNode(q);
  177. 		q->next = p->next;
  178. 		p->next = q;
  179. 		qpre->next = p;
  181. 	}
  182. 	
  183. }
  185. /*交换任意两个节点*/
  186. void SwapNode(Node*p,Node*q)
  187. {
  188. 	// if(LengthList(head)<2)
  189. 	// printf("Can not swap!The Length of list is:%d\r\n ",LengthList(head));
  190. 	/*检查是否是头尾节点*/
  191. 	/*对于头尾节点有四种情况
  192. 	*1.p头节点和q为中间节点
  193. 	*2.p尾节点和q为中间节点
  194. 	*3.q头节点和p为中间节点
  195. 	*4.q尾节点和p为中间节点
  196. 	*5.p头结点和q尾节点
  197. 	*6.q头结点和p尾节点
  198. 	*7.其他中间交换的情况
  199. 	*/
  200. 	/*2.两个节点是否相邻 除去头结点和下一节点相邻的情况，放在headanother处理*/
  201. 	if((p->next == q)&&(p !=head)&&(q !=head))
  202. 	Swanext(p,q);
  203. 	else if((q->next == p)&&(p !=head)&&(q !=head))
  204. 	Swanext(q,p);
  205. 	/*1.p头节点和q为中间节点*/
  206. 	else if((p == head)&&(q != end))
  207. 	SwapHeadAnother(p,q);
  208. 	/*2.p尾节点和q为中间节点*/
  209. 	else if ((p == end)&&(q != head))
  210. 	SwapEndAnother(p,q);
  211. 	/*3.q头节点和p为中间节点*/
  212. 	else if((q == head)&&(p != end))
  213. 	SwapHeadAnother(q,p);
  214. 	/*4.q尾节点和p为中间节点*/
  215. 	else if((q == end)&&(p != head))
  216. 	SwapEndAnother(q,p);
  217. 	/*5.p头结点和q尾节点*/
  218. 	else if((p == head)&&(q == end))
  219. 	SwapHeadEnd(p,q);
  220. 	/*6.q头结点和p尾节点*/
  221. 	else if((q == head)&&(p == end))
  222. 	SwapHeadEnd(q,p);	
  223. 	/*7.其他中间交换的情况*/
  224. 	else 
  225. 	SwapRandom(p,q);	
  226. }

5.归并排序

基本思想：归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。
作为一种典型的分而治之思想的算法应用，归并排序的实现由两种方法：
自上而下的递归（所有递归的方法都可以用迭代重写，所以就有了第 2 种方法）；
自下而上的迭代；
具体步骤：
  1.申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
  2.设定两个指针，最初位置分别为两个已经排序序列的起始位置；
  3.比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
  4.重复步骤 3 直到某一指针达到序列尾；
  5.将另一序列剩下的所有元素直接复制到合并序列尾。
时间复杂度：O(NlogN)
空间复杂度：O(N)
稳定排序：是
原地排序：否

在这里插入图片描述

  1. /*获取链表中间元素*/
  2. Node *getMiddleNode(Node *pList)
  3. {
  4.     if (pList == NULL)
  5.     {
  6.         return NULL;
  7.     }
  8.     Node *pfast = pList->next;
  9.     Node *pslow = pList;
  10.     while (pfast != NULL)
  11.     {
  12.          pfast = pfast->next;
  13.          if (pfast != NULL)
  14.          {
  15.              pfast = pfast->next;
  16.              pslow = pslow->next;
  17.          }
  18.  
  19.     }
  20.  
  21.     return pslow;
  22. }
  23.  /*合并有序链表，合并之后升序排列*/
  24. Node *MergeList(Node *p1,Node *p2) 
  25. {
  26.     if (NULL == p1)
  27.     {
  28.         return p2;
  29.     }
  30.     if (NULL == p2)
  31.     {
  32.         return p1;
  33.     }
  34.  
  35.     Node *pLinkA = p1;
  36.     Node *pLinkB = p2;
  37.     Node *pTemp = NULL;
  38. 	/*较小的为头结点，pTemp存下头结点*/
  39.     if (pLinkA->data <= pLinkB->data)
  40.     {
  41.         pTemp = pLinkA;
  42.         pLinkA = pLinkA->next;
  43.     }
  44.     else
  45.     {
  46.         pTemp = pLinkB;
  47.         pLinkB = pLinkB->next;
  48.     }
  49. 	/*初始化头结点，即头结点指向不为空的结点*/
  50.     Node *pHead = pTemp; 
  51.     while (pLinkA && pLinkB)
  52.     {
  53.         /*合并先放小的元素*/
  54. 		if (pLinkA->data <= pLinkB->data)
  55.         {
  56.             pTemp->next = pLinkA;
  57. 			/*保存下上一次节点。如果下一次为NULL，保存的上一次的节点就是链表最后一个元素*/
  58.             pTemp = pLinkA;
  59.             pLinkA = pLinkA->next;
  60.         }
  61.         else
  62.         {
  63.             pTemp->next = pLinkB;
  64.             pTemp = pLinkB;
  65.             pLinkB = pLinkB->next;
  66.         }
  67.  
  68.     }
  69. 	/*跳出循环时，有一个为空。把不为空的剩下的部分插入链表中*/
  70.     pTemp->next = pLinkA ? pLinkA:pLinkB; 
  71. 	head = pHead;
  72.     return pHead;
  73. 	
  74. }
  75. Node *MergeSort(Node *pList)
  76. {
  77.     if (pList == NULL || pList->next == NULL)
  78.     {
  79.         return pList;
  80.     }
  81. 	/*获取中间结点*/
  82.     Node *pMiddle = getMiddleNode(pList); 
  83. 	/*链表前半部分，包括中间结点*/
  84.     Node *pBegin = pList; 
  85. 	/*链表后半部分*/
  86.     Node *pEnd = pMiddle->next;
  87. 	/*必须赋值为空 相当于断开操作。pBegin--pMiddle pEnd---最后 */
  88.     pMiddle->next = NULL; 
  89. 	/*排序前半部分数据，只有一个元素的时候停止，即有序*/
  90.     pBegin = MergeSort(pBegin); 
  91. 	/*排序后半部分数据 递归理解可以参考PrintListRecursion;*/
  92.     pEnd = MergeSort(pEnd); 
  93. 	/*合并有序链表*/
  94.     return MergeList(pBegin,pEnd); 
  95. }

  大家的鼓励是我继续创作的动力，如果觉得写的不错，欢迎关注，点赞，收藏，转发，谢谢！
以上代码均为测试后的代码。如有错误和不妥的地方，欢迎指出。
图片来自网络，侵权请联系我删除

如遇到排版错乱的问题，可以通过以下链接访问我的CSDN。

CSDN:CSDN搜索“嵌入式与Linux那些事”

欢迎欢迎关注我的公众号：嵌入式与Linux那些事，领取秋招笔试面试大礼包（华为小米等大厂面经，嵌入式知识点总结，笔试题目，简历模版等）和2000G学习资料。

猜你在找的数据结构相关文章

【数据结构】键树
键树的基本概念 键树又称数字查找树（Digital Search Tree）。 它是一棵度大于等于2的树，...
【数据结构】绪论
[TOC] 基本概念 数据： 数据 是对客观事物的符号表示，在计算机科学中指所有能输入到计算机...
【数据结构】证明法
[TOC] 反证法 基本概念： 一般地，假设原命题不成立（即 在原命题的条件下，结论不成立），...
数据结构与算法系列之目录
最近抽空整理了&quot;数据结构和算法&quot;的相关文章。在整理过程中，对于每种数...
【数据结构】数组
[TOC] 矩阵在计算机图形学、工程计算中占有举足轻重的地位。在数据结构中考虑的是如何用最...
[操作系统]操作系统中断机制
1.当中断发生时，cpu立即进入核心态 2.当中断发生后，当前进程进入暂停状态，操作系统内核...
[日常] 浏览器前进后退与数据结构的思想
一张图保存一下 红点是当前地址 白色箭头是新打开页面 黑色箭头是后退页面 栈的思想 , 后退...
[算法] 开放寻址法解决哈希冲突方式
开放寻址法：又称开放定址法，当哈希冲突发生时，从发生冲突的那个单元起，按照一定的次序...
二叉树的基本概念介绍与代码实现（多图+代码）
@ 树的基本概念 图1 树的结点 结点：使用树结构存储的每一个数据元素都被称为“结点”。例...
史上最全单链表的增删改查反转等操作汇总以及5种排序算法(C语言)
1.准备工作 首先包含头文件，定义链表结构体，产生随即链表的范围，定义全局头尾节点。 #i...
LinuxWindowsCentOSUbuntuNginxWebServiceScalaMemcacheApacheRedisDockerBashAzureTomcatLNMPShell数据结构服务器运维网络安全
xebugnodemondocker-copydcoselasticsearcwindows-contdocker-windodocker-awsamazon-cloudenvoyproxyhashicorp-vaswisscomdevkafka-pythonzscalerphoton-osdocker-swarmkamongoogle-cloudconcoursewso2-ampersistent-vapi-managerprocess-manamanjarojenkins-workhypriotremoteapikeystonejsbitcoindbitcoin-test