单链表的两种排序(冒泡和插入)优化

最新推荐文章于 2022-01-23 16:20:34 发布
最新推荐文章于 2022-01-23 16:20:34 发布
阅读量725 收藏 4
点赞数 6
文章标签： 单链表 插入排序 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51340322/article/details/113280903
版权

单链表冒泡排序和插入排序及其优化(多角度理解)

均以从小到大的顺序为例！

一：冒泡排序法

冒泡排序要点：1. 单链表的遍历 2. 相邻两个节点的交换(情况多样)

  1. 首先，肯定是两层循环的嵌套，比方说最外层是这样：for(int i = 0; i < LengthList(head)-1; i++) 内层循环就比较多样了，这里就不举其他例子了，直接给出我写的一种(先等我说完)：

  2. 相邻节点的交换需要考虑(正常情况下)：(1). 节点数为2，头尾节点的交换 (2). 节点数为3以上包括3，头节点和相邻节点的交换 (3). 节点数为3以上包括3，相邻节点与尾节点的交换 (4). 节点数为4以上包括4，中间节点2，3的交换

    你肯定会想：在(2).中情况(1).和(2).不是一样的吗，都是头节点与相邻节点的交换？包括(3).和(4).不是一样的吗？诸如此类，其实冒泡排序就是这样，其实交换节点只要用一种方法就行了，但是，你在计算机内部排好序总有输出(要不然看不到)，这样就出大麻烦了，因为链表头部在动态变化着，也许排序完成后，头变成了第三个节点，这样从头打印直接会造成节点的丢失。

    一句话：交换节点考虑节点位置不同带来的诸多情况，是为了及时更新链表的头尾，说白了，就是讲，哪个节点与哪个节点交换会影响到表头或者表尾，而另外一些交换不会

    废话说完了，关门放代码：

    注：这里的表头head和表尾end均为全局变量

   void BubbleSort(void)
   {
   	   Node * pre, * p, * tail = NULL;
   	   pre = p = head;
   	   while (p->next != tail)
   	   {
   		   p = head->next;
   		   while (p != tail)
   		   {
   			   if (pre->num > p->num)
   			   { 
   			        SwapNode(pre, p);
   			        Node * temp = pre;
   				    pre = p;
   				    p = temp;
   			   } 
   			   pre = pre->next;
   			   p = p->next;
   		   }
   		   tail = pre;
   		   pre = p = head;
   	  }
      PrintList(head);

   ​   return;
   }

源代码会再最后给出，这里仅仅拿出部分函数分析

所以，想要改进目标已经很明确了

那就是，在原来的头节点前插入一个新的节点(数据域不处理)，使它与head相连

冒泡排序时，第一个数据实际上时第二个节点的数据，换句话说，新的头是个空头，它只是一个定位的作用，无论后面的节点怎么交换，这个空头节点的下一个节点一定可以作为头节点打印出整个链表的所以节点的数据

所以初步改进后代码如下：

   void Bubble_Sort(void)
   {
        AddFalseHead();
   	    Node * p, * q, * tail = NULL;
  
   ​	    while (head->next->next != tail)
   ​	    {
   ​		    p = head->next;
   ​		    q = p->next;
   ​		    while (q != tail)
   ​		    {
   ​			    if (p->num > q->num)
   ​			    {
   ​				   Node * pre = FindPreNode(p);
   ​				   pre->next = q;
   ​				   p->next = q->next;
   ​			  	   q->next = p;
   ​				   Node * temp = p;
   ​				   p = q;
   ​				   q = temp;
   ​			   }
   			   p = p->next;
   			   q = q->next;
   	        }
   		    tail = p;
   	}
   	while (end->next != NULL)
   	   end = end->next;
   	head = head->next;
   	PrintList(head);
   	
   	return;
}

最后改进 if(){}里面函数调用问题，尝试不用FindPreNode()函数进行节点交换

   void Bubble_Sort(void)
   {
   	   AddFalseHead();
   	   Node * p, * q, * tail = NULL;
     //神龙顾首不顾尾，头head的问题解决了，又有尾部问题
     //随之而来的问题是end没有及时更新，需要手动寻找(滑稽)
     //函数末尾用局部遍历寻找尾部 
      while (head->next->next != tail)
      {
      	  p = head;
      	  q = head->next;
      	  while (q->next != tail)
      	  {
      		  if (q->num > q->next->num)
      		  {
      			 p->next = q->next;
      			 Node * temp = q->next->next;
      		     q->next->next = q;
      			 q->next = temp;
      			 q = p->next;
   			  }
   			  p = p->next;
   			  q = q->next;
   		  }
      	  tail = q;
   	}
   //精简了上面 if(){}中节点的交换(至少不需要再调用函数) 
   	while (end->next != NULL)
   	   end = end->next;
   	head = head->next;
   	PrintList(head);
   
   	return;
}

源代码：

#include <stdio.h>
#include <stdlib.h>
#define N 10 

typedef struct Node
{
	int num;
    struct Node * next;
}Node;

Node * head = NULL;
Node * end = NULL;

void CreatList(void);
void BubbleSort(void);
void Bubble_Sort(void);
void PrintList(Node * head);
int LengthList(Node * temp);
void InsertListEnd(Node * p);
void SwapNode(Node * p, Node * q);
Node * FindList(Node * p);
void AddFalseHead(void);
Node * FindPreNode(struct Node * p);

int main(void)
{
	int len; 
	
	CreatList();
	len = LengthList(end);
	printf("len = %d\n", len);
	
//	InsertListEnd(end);
/*	len = LengthList(head);
	printf("len = %d\n", len);
*/	
	Bubble_Sort();
	
	return 0;
}

void CreatList(void)
{
	int n = N;
	
	while (n --)
	{
		Node * temp = (Node *)malloc(sizeof(Node));
		if (temp == NULL)
		{
			printf("Mallloc error!\n");
			exit(0);
		}
		else
		{
			printf("Plz input a number:\n");
			scanf("%d", &temp->num);
			temp->next = NULL;
			if (head == NULL)
			{
				head = temp;
				end = temp;
			}
			else 
			{
				end->next = temp;
				end = temp;
			}
		}
	}
	PrintList(head);
	
	return;
}

void PrintList(Node * head)
{
    if(head == NULL)
    {
        printf("Empty List!\n");
    }
    while (head)
    {
    	 if(head)
	       printf("->");
       printf("%d ", head->num);
       head = head->next;
    }
    printf("\n");
}

void InsertListEnd(Node * p)
{
	if (head == NULL)
	{
		printf("Empty List!\n");
		return;
	}
	else
	{
		Node * pt = FindList(p);
	    Node * temp = (Node *)malloc(sizeof(Node));
	   
		printf("Plz input a number:\n");
		scanf("%d", &temp->num);
		if (pt == end)
		{
			pt->next = temp;
			end = temp;
			end->next = NULL;
   	}
   	else
   	{
   		temp->next = pt->next;
   		pt->next = temp;
   		
		}
		printf("InsertListENd's mission is over!\n");
		PrintList(head);
	}
	
	return;
}

int LengthList(Node * temp)
{
	int len = 1;
	Node * pt = head;
	while (pt != temp)
	{
		len++;
		pt = pt->next;
	}

	return len;
}

void SwapNode(Node * p, Node * q)
{
	if (p == q || p == NULL || q == NULL)
	{
		printf("Ineffective swap!\n");
		return;
	}
	
	if(LengthList(p) > LengthList(q))
	{
		Node * temp = p;
		p = q;
		q = temp;
	}
	
	if (p == head)
	{
		if (p->next == q && q == end)
		{
		   end->next = p;
		   p->next = NULL;
		   head = end;
		   end = head->next;	
		}
	
	   if (p->next == q && q != end)
		{
			p->next = q->next;
			q->next = p;
			head = q;
		}
		
		else if (p->next != q && q == end)
		{
			Node * temp = FindPreNode(q);
			temp->next = p;
			q->next = p->next;
			p->next = NULL;
			end = p;
			head = q;
		}
		
		else if (p->next != q && q != end)
		{
			Node * temp = FindPreNode(q);
			temp->next = p;
			p = p->next;
			head->next = q->next;
			q->next = p;
			head = q;
		}
		
		else   
		   printf("1.Sorry! Not take into account this case!\n");
	}
	else
	{
		if (p->next == end && q == end)
		{
			Node * temp = FindPreNode(p);
			temp->next = q;
			q->next = p;
			p->next = NULL;
			end = p;
		}
		
		else if (p->next != end && q == end)
		{
			Node * temp1 = FindPreNode(p);
			Node * temp2 = FindPreNode(q);
			temp1->next = q;
			q->next = p->next;
			temp2->next = p;
			p->next = NULL;
			end = p;
		}
		
		else if (p->next == q && q != end)
		{
			Node * temp = FindPreNode(p);
			temp->next = q;
			p->next = q->next;
			q->next = p;
		}
		
		else if (p->next != q && q != end)
		{
			Node * temp1 = FindPreNode(p);
			Node * temp2 = FindPreNode(q);
			Node * pt = p->next;
			temp1->next = q;
			p->next = q->next;
			q->next = pt;
			temp2->next = p;
		}
		
		else
		   printf("2.Sorry! Not take into account this case!\n");
	}
	
//	PrintList(head);
	
	return;
}

Node * FindPreNode(struct Node * p)
{
	struct Node * temp = head;
	if (head == NULL)
	{
		printf("Empty list!\n");
		return NULL;
	}
	while (temp->next != p)
		temp = temp->next;
	
	return temp; 
}

Node * FindList(Node * p)
{
	struct Node * temp = head;
	if (head == NULL)
	{
		printf("Empty list!\n");
		return NULL;
	}
	else
	{
		while (temp)
		{
			if (temp == p)
			{
			   return temp;
			}
			temp = temp->next;
		}
	
		return NULL;
	}
}

void AddFalseHead(void)
{
	Node * phead= (Node *)malloc(sizeof(Node));
	phead->next = head;
	head = phead;
	printf("AddFalseHead's mission is over!\n");
   
	return ;
}

void BubbleSort(void)
{
	Node * pre, * p, * tail = NULL;
	pre = p = head;
	while (p->next != tail)
	{
		p = head->next;
		while (p != tail)
		{
			if (pre->num > p->num)
			{ 
			   SwapNode(pre, p);
			   Node * temp = pre;
				pre = p;
				p = temp;
			} 
			pre = pre->next;
			p = p->next;
		}
		tail = pre;
		pre = p = head;
	}
	PrintList(head);
	
	return;
}

void Bubble_Sort(void)
{
	Node * p, * q, * tail = NULL;
	AddFalseHead();
//神龙顾首不顾尾，头head的问题解决了，又有尾部问题
//随之而来的问题是end没有及时更新，需要手动寻找(滑稽)
//函数末尾用局部遍历寻找尾部 
/*	方法一：
    while (head->next->next != tail)
	{
		p = head->next;
		q = p->next;
		while (q != tail)
		{
			if (p->num > q->num)
			{
				Node * pre = FindPreNode(p);
				pre->next = q;
				p->next = q->next;
				q->next = p;
				Node * temp = p;
				p = q;
				q = temp;
			}
			
			p = p->next;
			q = q->next;
      }

		tail = p;
	}
*/
// 方法二：
   while (head->next->next != tail)
   {
   	p = head;
   	q = head->next;
   	while (q->next != tail)
   	{
   		if (q->num > q->next->num)
   		{
   			p->next = q->next;
   			Node * temp = q->next->next;
   		   q->next->next = q;
   			q->next = temp;
   			q = p->next;
			}
			p = p->next;
			q = q->next;
		}
     	tail = q;
	}
//	精简了上面 if(){}中节点的交换(至少不需要再调用函数) 
	while (end->next != NULL)
	   end = end->next;
	head = head->next;
	PrintList(head);
	
	return;
}

注：源码包含三个冒泡排序：BubbleSort(), Bubble_Sort()方法一，Bubble_Sort()方法二，分别对应上述我讲的三种思路

二：插入排序法

插入排序的要点(思路)：1. 插入位置的寻找顺序 2. 对插入节点的处理

  1. 建议按照单链表的顺序从头寻找，找到位置就在该位置前插入

  2. 需要执行插入的节点有两种处理方式，

    一："复刻"此节点，插入位置后，删除该节点，比如1->3->5->4->2，现将4插入5前面，先(第一 步)插 1->3->4->5->4->2，后(第二步)删 1->3->4->5->2

    二：挖出该节点，再插入位置，1->3->5->4->2， 1->3->5->2，1->3->4->5->2

    好了，准备完成，依旧是安装"假表头"，用AddFalseHead()建一个空头，执行插入

    处理方式一代码：

void InsertSort(void)
{
	AddFalseHead();
	Node * pst = head->next;
	Node * q = head->next->next;
	
	while (q != NULL)
	{
		Node * qpre = q;
		while (pst != q)
		{
			if (pst->num > q->num)
			{
				Node * temp = q->next;
			    InsertListHead(pst, q);
			    q = temp; break;
			}
			pst = pst->next;
		}
		if (qpre == q)   q = q->next;
		pst = head->next;
	}
	head = head->next;
	PrintList(head);
	
	return;
}

处理方式二代码：

void InsertSort(void)
{
	AddFalseHead();
    Node * p = head->next;//第一节点 
    Node * q = p->next;
   
	while (q != NULL)
	{
		Node * pst = head->next;
		while (pst != q)
		{
			if (pst->num > q->num)
			{
				Node * temp = FindPreNode(pst);
				p->next = q->next;
				temp->next = q;
				q->next = pst;
				q = p;  break;
			}
			pst = pst->next;
		}
		if (p != q)
		  p = p->next;
		q = q->next;
	}	
	head = head->next;
	PrintList(head);
	
	return;
}

源代码：

#include <stdio.h>
#include <stdlib.h>
#define N 10

typedef struct Node
{
	int num;
   struct Node * next;
}Node;

Node * head = NULL;
Node * end = NULL;

void CreatList(void);
void InsertSort(void);
void AddFalseHead(void);//"安(装)假头"，即在头节点前再置新节点作为假头 
void DeletList(Node * movp);//称其为假头是因为其数据域为空(无效数据)，便于插入 
void PrintList(Node * head);
Node * FindPreNode(Node * p);
void InsertListHead(Node * temp, Node * movp);

int main(void)
{
	CreatList();
	PrintList(head);
	InsertSort();
	
	return 0;
} 

void CreatList(void)
{
	int n = N;
	
	while (n --)
	{
		Node * pt = (Node *)malloc(sizeof(Node));
		printf("Plz input a number:\n");
		scanf("%d", &pt->num);
		if (head == NULL)
		{
			head = pt;
			end = head;
		}
		else
		{
			end->next = pt;
			end = pt;
			end->next = NULL;
		}
	}
	
	return;
}

void InsertListHead(Node * temp, Node * movp)
{
	Node * pre = FindPreNode(temp);
	Node * pt = (Node *)malloc(sizeof(Node));
	pt->num = movp->num;
	pre->next = pt;
	pt->next = temp;
	
	DeletList(movp);
	PrintList(head->next);
	
	return;
}

void DeletList(Node * movp)
{
	struct Node * pt = head;
	
	while (pt->next != movp)  pt = pt->next;
	if (end == movp)
	{
	   end = pt;
	   end->next = NULL;
	}
	else
	   pt->next = movp->next;
	free(movp);
}

Node * FindPreNode(struct Node * p)
{
	struct Node * temp = head;
	
	while (temp->next != p) 
	   temp = temp->next;
	   
	return temp; 
}

void PrintList(Node * head)
{
    if(head == NULL)
    {
        printf("Empty List!\n");
    }
    while (head)
    {
    	 if(head)
	       printf("->");
       printf("%d ", head->num);
       head = head->next;
    }
    printf("\n");
}

void AddFalseHead(void)
{
	Node * pt = (Node *)malloc(sizeof(Node));
	pt->next = head;
	head = pt;
} 

void InsertSort(void)
{
	AddFalseHead();
/*	方法一：
    Node * pst = head->next;
	Node * q = head->next->next;
	
	while (q != NULL)
	{
		Node * qpre = q;
		while (pst != q)
		{
			if (pst->num > q->num)
			{
				Node * temp = q->next;
			   InsertListHead(pst, q);
			   q = temp; break;
			}
			pst = pst->next;
		}
		if (qpre == q)   q = q->next;
		pst = head->next;
	}
	head = head->next;
	PrintList(head);

*/ 
// 方法二：
   Node * p = head->next;//第一节点 
   Node * q = p->next;
   
	while (q != NULL)
	{
		Node * pst = head->next;
		while (pst != q)
		{
			if (pst->num > q->num)
			{
				Node * temp = FindPreNode(pst);
				p->next = q->next;
				temp->next = q;
				q->next = pst;
				q = p;  break;
			}
			pst = pst->next;
		}
		if (p != q)
		  p = p->next;
		q = q->next;
	}	
	head = head->next;
	PrintList(head);
	
	return;
}

注：源码中包含两个插入排序，InsertSort()方法一，InsertSort()方法二，分别对应上述我讲的两种思路
所有函数在源代码中均可找到，两个源代码中函数可能同名，内容不同作用不同，如有兴趣可以直接下载源码进行调试，拜拜啦

@Aurora,
关注
C语言冒泡排序：简单版+优化版+链表的冒泡排序
weixin_50545743的博客
12-26 1459
冒泡排序 冒泡排序(Bubble Sort)，又被称为气泡排序或泡沫排序。 它是一种较简单的排序算法。它会遍历若干次要排序的数列，每次遍历时，它都会从前往后依次的比较相邻两个数的大小；如果前者比后者大，则交换它们的位置。这样，一次遍历之后，最大的元素就在数列的末尾！采用相同的方法再次遍历时，第二大的元素就被排列在最大元素之前。重复此操作，直到整个数列都有序为止！ · · · 简单版–直接法 #include<stdio.h> #define N 6 void swap(int *a,int *
单链表的排序（插入，选择，冒泡）
路漫远 吾求索
12-20 973
1.插入排序 链表的创建等系列操作代码详见单链表实现 void Insert_Sort(LinkList &L) { // 插入排序，变更结点连接 Node *p = L->next, *head; // p指针指向每次要插入的结点，head指针用于找到插入的位置 Node *temp = p->next; // temp指针 指向 p指针后继结点，避免断链 p->next = NULL; // 构造一个结点的有序表
冒泡算法的优化
lengyuhong的专栏
10-12 8969
 冒泡算法的主要思想：      冒泡排序和插入排序相类似，都是简单的排序算法 ，时间复杂度O(N^2)      算法思想：     1） 有n个数（存放在数组a[0]-a[n-1]中），第一趟将每相邻两个数比较，小的换到前面，经n-1次两两相邻比较后，最大的数已经“沉底”，放到最后的一个位置，小数上升“浮起”     2） 第二趟对余下的n-1个数（最大的数已经“沉底”），按上
冒泡排序和优化
weixin_33874713的博客
06-30 85
冒泡排序作为一种交换排序方法，可以实现降序和升序。 优化：去除排序完成后的,轮数空转时间（bubblingSortx方法） /** * 冒泡算法，用于排序: 9 8 7 6 5 4 3 2 1 比较轮数，每一轮比较次数，每一次将相邻的两个数进行比较。 第一轮: 第1次：8 9 7 6 5 4 3 2 1 2：8 7 9 6 ...
单链表冒泡排序（优化）
饭饭的博客
05-27 650
void SortList(PSListNode pHead) {                  PSListNode pTailNode = NULL ;                  PSListNode pNode = NULL ;                  PSListNode pPreNode = NULL ;            
链表的三种插入排序+冒泡排序
CppYyds的博客
06-13 308
不改变结点位置的插入排序 结合数组的实现方式，唯一的不同在于从前往后遍历，但是这种插入排序对链表来说还是太慢了。 class Solution { public: ListNode* insertionSortList(ListNode* head) { if(!head||!head->next) return head; ListNode* cur = head->next; ListNode* pre =
C#数据结构（顺序表，单链表，顺序表应用，冒泡排序，折半查找）
11-10
在IT领域，尤其是在编程实践中，数据结构和算法是至关重要...顺序表和单链表展示了不同的存储方式，冒泡排序和折半查找则展示了不同的排序和查找策略。通过实际编写代码并运行这些操作，你将能更好地掌握这些核心概念。
shujujiegou.rar_C 单链表 排序_单链表
09-23
2. **插入操作**：在单链表中插入节点分为两种情况：头部插入和任意位置插入。头部插入时，新节点会成为链表的第一个节点；在任意位置插入，需要找到插入点的前一个节点，然后修改其指针指向新节点，再将新节点的...
数据结构实验1.4：带表头结点单链表的非递减排序.doc
10-29
实验中提到的非递减排序可以采用多种算法实现，如冒泡排序、插入排序、选择排序等。这里选择的是简单选择排序，该算法的工作原理是每次从未排序的部分选取最小（或最大）的元素放到已排序部分的末尾，直到所有元素...
冒泡排序-顺序表与单链表的优化算法
AlexOne
04-25 658
冒泡排序有多种。下面是比较通用的一种： // 顺序表的冒泡排序 void bubbleSort(int R[],int n){ int i,j,flag; for(i=n-1;i>0;i--){ flag=1; for(j=0;j<i;j++){ if(R[j]>R[j+1]){ ...
冒泡优化
withtony的博客
04-08 240
https://blog.csdn.net/wangzhiping321/article/details/82381704
冒泡的优化
JinlongCai的博客
05-21 471
冒泡的优化
吃透排序——直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序、堆排序、归并排序、基数排序、外部排序（包括详细代码、排序过程图解，特别的注意事项）
weixin_43914272的博客
04-15 1462
吃透排序 有个各类算法可视化的网站很不戳，对算法的执行过程不清晰地可以lou一眼，可以加深对算法的理解 网站地址：https://www.cs.usfca.edu/~galles/visualization/Algorithms.html 以排序算法为例，点开网站找到排序模块 点击任何一个排序进入，然后就可以愉快看到各种排序的动画 先上思维导图 什么是算法的稳定性？ 文绉绉地说就是排序后，能使关键字相同的元素保持原来顺序中的相对位置不变 其实 ......
单链表排序（冒泡法）
WhiskyCocktail的博客
10-10 1067
通用冒泡法排序//1.0单链表排序升序（冒泡排序） void BubbleSortLinkList(LinkList L) { LinkList Tail = NULL; int flag = 0; if (L->next == NULL || L == NULL){ return; } while (L!=Tail) {
单链表的应用--对单链表排序
qq_39400324的博客
01-23 1550
  对单链表进行排序，利用前文写好的链表的框架，在链表类中补充Sort方法。 对单链表排序一、问题分析二、代码分析1.链表类LinkList2.链表方法Sort三、测试代码1.主函数2.输出结果四、源代码获取（免积分） 一、问题分析   给你一个链表,请将其按升序排列并输出排序后的结果。 示例 1： 输入： [4,2,1,3] 输出：[1,2,3,4] 示例 2： 输入： [-1,5,3,4,0] 输出：[-1,0,3,4,5] 二、代码分析 1.链表类LinkList   在链表类中声明Sort方
冒泡排序的优化
旺帝春心
03-20 291
基本思想：冒泡排序（默认是从小到大排序）是指在数组中，遍历0-n-1的元素数组，第一个数A与第二个数B进行对比，若A>B,则交换，否则，不交换。然后第二个数B与第三个数C进行对比，以此类推直到到处第二个元素与最后一个元素进行对比。这时，第一趟排序结束后，就将最大值 放在了数组的最后一位，然后遍历0到n-2的元素数组，以此类推。 方法： 冒泡（没优化）：通过两层for循环实现。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值