数据结构链表冒泡排序

最新推荐文章于 2023-09-28 06:00:00 发布
最新推荐文章于 2023-09-28 06:00:00 发布
阅读量789 收藏 1
点赞数
分类专栏： 链表 C语言 数据结构 文章标签： 链表 c语言 指针 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46574762/article/details/108098262
版权
C语言 同时被 3 个专栏收录
11 篇文章 2 订阅
订阅专栏
数据结构
7 篇文章 0 订阅
订阅专栏
链表
3 篇文章 0 订阅
订阅专栏

文章目录

链表冒泡排序

前序

	6000字文章，建议先自上而下的划分函数，读者先自己实现一下功能，
   	然后再看该文章才会目标明确，有方向感。
   	这里采用链表冒泡排序，需要有二级指针和链表的基础。

源程序

/*	单链表 排序 
@author:	赵雨腾
@data:		12th	March	2020 
@input：	 49 38 65 97 76 13 27 49 -1
@output：	 The new list is:13 27 38 49 49 65 76 97
*/
#include<stdio.h>
#include<stdlib.h>
#define ElementType int
struct listNode{
	 ElementType data;
	struct listNode * nextPtr; 
};
typedef struct listNode LISTNODE;
typedef LISTNODE * LISTNODEPTR;

int getSize (LISTNODEPTR currentPtr);//长度 
void bubbleSort(LISTNODEPTR headPtr,int len);//冒泡 
void createListHead(LISTNODEPTR * headPtrPtr);//创建空头 
void insertEnd2(LISTNODEPTR *lastPtrPtr, ElementType value);//尾插2 
void destroyList(LISTNODEPTR headPtr);//free 
void printfList(LISTNODEPTR currentPtr);//打印 

int main(void)
{
	LISTNODEPTR headPtr,lastPtr,currentPtr;
	createListHead(&headPtr);//创建空头 
	lastPtr = headPtr;//尾指针就是空头 
	
	int num,len; 
	scanf("%d",&num);
	
	 //链表创建 
	while(num!=-1){
		insertEnd2(&lastPtr,num);
		scanf("%d",&num);
	}
	
	len = getSize(headPtr); //长度 
	bubbleSort(headPtr,len); //冒泡 

	printf("The new list is:") ;
	printfList(headPtr);//打印 		
		
	destroyList(headPtr);//free 
} 
//长度 
int getSize (LISTNODEPTR currentPtr){
	int num = -1;/*-1的初始值是为了抵消空节点的计数*/
	while(currentPtr!=NULL){
		num++;
		currentPtr=currentPtr->nextPtr;
     } 
	return (num);
}
//冒泡	排序 
void bubbleSort(LISTNODEPTR headPtr,int len)
{
	LISTNODEPTR previousPtr,currentPtr,backPtr,tempPtr;
	int i,j;
	
	for(i=len-1; i>=1 ;i--)
	{
		previousPtr						=headPtr;
		currentPtr						=previousPtr->nextPtr;
		backPtr							=currentPtr->nextPtr;	
//		tempPtr							=backPtr->nextPtr;
		
		for(j=0; j<=i-1 ;j++)
		{
			if(currentPtr->data > backPtr->data)
			{
				tempPtr						=backPtr->nextPtr;
				//交换  current  back  指针域 
				previousPtr->nextPtr		=backPtr;
				backPtr->nextPtr			=currentPtr;
				currentPtr->nextPtr			=tempPtr; 
				//p b c	修正 
				previousPtr=backPtr;
				currentPtr=currentPtr;
				backPtr=currentPtr->nextPtr;			
			}
			else
			{
				//p c b	修正 
				previousPtr					=currentPtr;
				currentPtr					=backPtr;
				backPtr						=backPtr->nextPtr;				
			}

		}

	} 
} 
//空头 
void createListHead(LISTNODEPTR * headPtrPtr){
	*headPtrPtr = (LISTNODEPTR)malloc(sizeof(LISTNODE));
	(*headPtrPtr)->nextPtr=NULL;
}
//尾插 
void insertEnd2(LISTNODEPTR *lastPtrPtr, ElementType value){
	LISTNODEPTR newPtr;
	newPtr = (LISTNODEPTR)malloc(sizeof(LISTNODE));
	if(newPtr!=NULL){
		//	上膛 
		newPtr->data		=value;
		newPtr->nextPtr		=NULL;
		// 	链接 
		(*lastPtrPtr)->nextPtr=newPtr;
		//修正 
		*lastPtrPtr			=newPtr;
	}
} 
//free 
void destroyList(LISTNODEPTR headPtr){
	LISTNODEPTR tempPtr;
	while(headPtr!=NULL){
		tempPtr			=headPtr;
		headPtr			=headPtr->nextPtr;
		free(tempPtr);
	}
} 
//打印 
void printfList( LISTNODEPTR currentPtr)
{
	//跳过	空节点 
	currentPtr = currentPtr->nextPtr;
	if(currentPtr!=NULL)
	{
		//打印 
		while(currentPtr!=NULL){
			printf("%d ",currentPtr->data);
			currentPtr = currentPtr->nextPtr;
		}
	}
}

讲解

头文件
#include<stdio.h>
#include<stdlib.h>
结构体
#define ElementType int

struct listNode{
	 ElementType data;
	struct listNode * nextPtr; 
};
typedef struct listNode LISTNODE;
typedef LISTNODE * LISTNODEPTR;

// LISTNODE 定义结构体
// LISTNODEPTR 定义结构体指针

主函数
int main(void)
{
	LISTNODEPTR headPtr,lastPtr,currentPtr;
	createListHead(&headPtr);//创建空头 
	lastPtr=headPtr;//尾指针就是空头 
	
	int num,len; 
	scanf("%d",&num);
	
	 //链表创建 
	while(num!=-1){
		insertEnd2(&lastPtr,num);
		scanf("%d",&num);
	}
	
	len = getSize(headPtr); //长度 
	bubbleSort(headPtr,len); //冒泡 

	printf("The new list is:") ;
	printfList(headPtr);//打印 		
		
	destroyList(headPtr);//free 
}
void createListHead(LISTNODEPTR * headPtrPtr);//创建空头

// 函数接口：LISTNODEPTR * 是二级指针
// 函数调用：createListHead(&headPtr);//创建空头
// 函数定义如下：

//空头 
void createListHead(LISTNODEPTR * headPtrPtr){
	*headPtrPtr=(LISTNODEPTR)malloc(sizeof(LISTNODE));
	(*headPtrPtr)->nextPtr=NULL;
}
void insertEnd2(LISTNODEPTR *lastPtrPtr, ElementType value);//尾插2

//函数接口：
// LISTNODEPTR *是二级指针
// ElementType value 待排序的元素，这里是int类型
// 函数调用：insertEnd2(&lastPtr,num);//尾插创建列表
// 函数定义如下：

//尾插 
void insertEnd2(LISTNODEPTR *lastPtrPtr, ElementType value){
	LISTNODEPTR newPtr;
	newPtr = (LISTNODEPTR)malloc(sizeof(LISTNODE));
	if(newPtr!=NULL){
		//	上膛 
		newPtr->data		=value;
		newPtr->nextPtr		=NULL;
		// 	链接 
		(*lastPtrPtr)->nextPtr=newPtr;
		//修正 
		*lastPtrPtr			=newPtr;
	}
}

// 该函数在主函数中的调用如下：

	LISTNODEPTR headPtr,lastPtr,currentPtr;
	createListHead(&headPtr);//创建空头 
	lastPtr=headPtr;//尾指针就是空头 
	
	int num,len; 
	scanf("%d",&num);
	
	 //链表创建 
	while(num!=-1){
		insertEnd2(&lastPtr,num);
		scanf("%d",&num);
	}
int getSize (LISTNODEPTR currentPtr);//长度

// 函数接口： LISTNODEPTR 一级指针
// 函数调用： len=getSize(headPtr); //长度
// 函数定义如下：

//长度 
int getSize (LISTNODEPTR currentPtr){
	int num=-1;/*-1的初始值是为了抵消空节点的计数*/
	while(currentPtr!=NULL){
		num++;
		currentPtr=currentPtr->nextPtr;
     } 
	return (num);
}
void bubbleSort(LISTNODEPTR headPtr,int len);//冒泡

// 函数接口： LISTNODEPTR 一级指针
// 函数调用： bubbleSort(headPtr,len); //冒泡
// 函数定义如下：

//冒泡	排序 
void bubbleSort(LISTNODEPTR headPtr,int len)
{
	LISTNODEPTR previousPtr,currentPtr,backPtr,tempPtr;
	int i,j;
	
	for(i=len-1;i>=1;i--)
	{
		previousPtr						=headPtr;
		currentPtr						=previousPtr->nextPtr;
		backPtr							=currentPtr->nextPtr;	
//		tempPtr							=backPtr->nextPtr;
		
		for(j=0;j<=i-1;j++)
		{
			if(currentPtr->data > backPtr->data)
			{
				tempPtr						=backPtr->nextPtr;
				//交换  current  back  指针域 
				previousPtr->nextPtr		=backPtr;
				backPtr->nextPtr			=currentPtr;
				currentPtr->nextPtr			=tempPtr; 
				//p b c	修正 
				previousPtr=backPtr;
				currentPtr=currentPtr;
				backPtr=currentPtr->nextPtr;			
			}
			else
			{
				//p c b	修正 
				previousPtr					=currentPtr;
				currentPtr					=backPtr;
				backPtr						=backPtr->nextPtr;				
			}

		}

	} 
}

// 该函数在主函数中的调用如下：

	len = getSize(headPtr); //长度 
	bubbleSort(headPtr,len); //冒泡
void printfList(LISTNODEPTR currentPtr);//打印

// 函数接口：LISTNODEPTR 一级指针
// 函数调用： printfList(headPtr);//打印
// 函数定义如下：

//打印 
void printfList( LISTNODEPTR currentPtr)
{
	//跳过	空节点 
	currentPtr=currentPtr->nextPtr;
	if(currentPtr!=NULL)
	{
		//打印 
		while(currentPtr!=NULL){
			printf("%d ",currentPtr->data);
			currentPtr=currentPtr->nextPtr;
		}
	}
}

// 该函数在主函数中的调用如下：

	printf("The new list is:") ;
	printfList(headPtr);//打印
void destroyList(LISTNODEPTR headPtr);//free

// 函数接口：LISTNODEPTR 一级指针
// 函数调用： destroyList(headPtr);//free
// 函数定义如下：

//free 
void destroyList(LISTNODEPTR headPtr){
	LISTNODEPTR tempPtr;
	while(headPtr!=NULL){
		tempPtr			=headPtr;
		headPtr			=headPtr->nextPtr;
		free(tempPtr);
	}
}

// 该函数在主函数中的调用如下：

	destroyList(headPtr);//free

结束语

	不妥之处，还请读者斧正~
待木成植
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
DuLinkBubbleSort 双向链表实现冒泡排序
06-07
冒泡排序是一种基础的排序算法，它通过重复遍历待排序的序列，比较相邻元素并交换位置，使得每个元素都能“浮”到其应该在的位置...通过这个练习，你可以深化对数据结构和算法的理解，特别是链表操作和排序算法的应用。
单链表的冒泡排序（C/C++实现）
热门推荐
suhuamo的博客
06-22 4万+
前言 大家在做需要排名的项目的时候，需要把各种数据从高到低排序，如果用的冒泡排序的话，处理数组是十分简单的,因为数组的存储空间的连续的，可以通过下标就可以简单的实现，但如果是链表的话，是随机分配的，不能像数组那样通过下标就直接实现。所以在这里给大家介绍一个简单一点的冒泡排序 冒泡排序 冒泡排序的是交换排序其中的一种，主要思想是每一个元素与后一个元素比较，若这个元素大于后一个元素，则交换这两个元素的位置（这里采用从小到大排序），第一次排序后最后一个数已经变成了最大数，再进行n-2次排序即可完成（假设有n个数据
万字长文，链表排序算法——冒泡排序、选择排序、插入排序、归并排序、快速排序、计数排序、桶排序、基数排序精讲及python实现
白话机器学习
06-04 3633
在数组排序中，常见的排序算法有：冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序等。而对于链表排序而言，因为链表不支持随机访问，访问链表后面的节点只能依靠next指针从头部顺序遍历，所以相对于数组排序问题来说，链表排序问题会更加复杂一点。下面先来总结一下适合链表排序与不适合链表排序的算法：冒泡排序选择排序插入排序归并排序快速排序计数排序桶排序基数排序。希尔排序。堆排序。希尔排序为什么不适合链表排序？希尔排序：希尔排序中经常涉及到对序列中第。
【数据结构与算法】单链表的排序算法(选择，冒泡，递归）
摸鱼小小虫的博客
11-27 6438
链表的选择排序思想与数组的排序类似，但是链表需要先找到里面最小或者最大的值，然后将这个值用改链语句进行操作。接下来我们进行排序，首先选取一个基准点，如何将比基准点大/小的值放左边，比基准点小/大的放右边。我们先看这个改链语句的操作（min是笔者打错了应该是max，但是图已经画好了就没有改）移动q这个指针找到最大的min，然后利用i保存q的前一个节点这样就能找到min_on.数组快速排序的思想和链表的一样，主要问题就是存在改链的操作。然后我们就可以将链表进行排序了，完整的代码如下。此时我们将2下沉到底部；
链表冒泡排序总结（C语言 两种解决方案）
计算机科学与技术专业学生的成长之路
04-05 1万+
在大一上学期，我们学了冒泡排序，选择排序，插入排序等等，而今天主要详解一下链表的冒泡排序的问题。（边看代码，边讲解） 首先，回顾一下，什么叫做冒泡排序。冒泡排序是一种时间复杂度在n的平方下的排序；每次循环都是比较前后两项，要么以从小到大排序，要么从大到小排序。 第一种： struct node *bubblesort(struct node *headptr)//接受头指针，链表的开端,首节点不...
C++ 五大链表排序（冒泡、插入、选择、归并、快排）
weixin_44178960的博客
08-18 4940
C++ 五大链表排序（冒泡、插入、选择、归并、快排）
数据结构C++单链表冒泡法排序
12-06
数据结构，单链表冒泡法排序数据结构，C++实现，可输入式程序
链表排序北邮数据结构实验
11-13
链表排序北邮数据结构实验报告 链表排序是数据结构中的一种基本操作，旨在对链表中的元素进行排序。该实验报告旨在使用链表实现各种排序算法，并进行比较。 一、实验要求 实验要求使用链表实现以下五种排序...
数据结构实例&二叉树建立遍历冒泡排序
08-31
在这个主题中，我们将深入探讨数据结构的一些重要实例，特别是二叉树及其遍历方法，以及冒泡排序和快速排序这两种常见的排序算法。 首先，让我们来了解数据结构。数据结构不仅仅是关于数据的简单集合，它更关乎于...
数据结构链表树图查找排序
09-20
链表、树、图、查找和排序是数据结构领域内的五个关键知识点，它们在编程和算法设计中起着至关重要的作用。 1. **链表**：链表是一种线性数据结构，与数组不同，它不连续存储元素。每个元素称为节点，包含数据和...
VS debug记录
alangaixiaoxiao的博客
12-25 131
错误提示： error C4996: ‘itoa’: The POSIX name for this item is deprecated 原因： 新版本的vs对旧有的函数itoa进行了安全检查，所以使用新版本的vs会提示错误，而旧版本的没问题。 解决办法： 1、使用新函数 _itoa 2、如果非要使用旧函数也是可以的，加上宏定义即可 #define _CRT_NONSTDC_NO_DEPRECA...
详解单链表冒泡排序
oTheodore的博客
05-11 2673
C语言，对单链表进行冒泡排序
链表冒泡排序
Gary_Hendrix的专栏
07-22 1156
任意两个相邻节点p、q位置互换图示:      假设p1->next指向p，那么显然p1->next->next就指向q,      p1->next->next->next就指向q的后继节点，我们用p2保存      p1->next->next指针。即：p2=p1->next
链表冒泡排序最详细的解释
qq_45873949的博客
10-18 5826
我也是小白一枚~,最近接触数据结构做到了一个关于多项式相加的问题,但是输出的多项式x的幂次都是无规律性的,这就让我开始想到刚开始我们学的冒泡排序,根据冒泡排序的原理,我实现了链表冒泡排序。 本质上来说:普通的冒泡排序和链表的冒泡排序是一样的,只不过链表的冒泡排序的内部需要结点的next不断的改变,但是从表面来看无非也是相邻的进行比较,重复n-1次,确定n个数。 废话少说,直接上代码(有详细解释,小白一看也会懂/偷笑) void AdjustList(pointer head)//链表冒泡排序,按X的幂次从小
链表的冒泡排序算法
你是最胖的
12-22 3011
链表的冒泡排序
链表排序--冒泡法
Paranoid
10-17 3253
对于排序，相信大家都不陌生，对于数组来说，我们基本能熟练应用许多排序，像冒泡，选择，快排等等。对于链表的排序，在上学期做课程设计的时候忽略了这个问题，然后在最近才进行了实际的操作，结果发现问题还挺多的，实际解决起来学到了一些东西，决定给大家分享一下。 排序的代码首先，给大家先把链表排序的代码附上，随后我会说明其中运行的过程，还有我当初写的时候，碰到的问题。void buttle_sort(node
数组、单链表冒泡排序——C语言实现
m0_47329175的博客
08-30 2216
数组冒泡排序 冒泡排序的原理 从左到右，相邻元素进行比较。每次比较一轮，就会找到序列中最大的一个或最小的一个。这个数就会从序列的最右边冒出来。 举例 假如有一堆数据： 进行第一轮比较 第一次：80与31比较，80 > 31，交换 第二次:80与-4比较，80 > -4，交换 第三次:80与36比较，80 > 36，交换 第四次:80与-8比较，80 > -8，交换 此时，第一轮结束，最大值80已经到了最右边，一共进行了四次比较 第二轮比较 （下面就不添加图片了） 第一
链表的冒泡排序
PdKingLiu
05-06 2765
首先应该介绍一下冒泡的思想（升序为例） 升序排列：从第一个元素开始，对数组中两两相邻的元素比较，将值较小的元素放在前面，值较大的元素放在后面，一轮比较完毕，一个最大的数沉底成为数组中的最后一个元素，一些较小的数如同气泡一样上浮一个位置.N个数，经过N-1轮比较后完成排序。 引用大话数据结构的一张图 链表的排序 其实链表排序的思想都是一样的，就在交换上有点差异 假设结构体如...
【数据结构】冒泡排序，快速排序的学习知识总结
最新发布
小人物，大梦想！
09-28 514
冒泡排序，快速排序的算法思想和代码实现
C语言数据结构单链表的冒泡排序和查找
06-13
好的，下面是C语言单链表的冒泡排序和查找的实现方法： 1. 单链表的冒泡排序 冒泡排序是一种简单的排序算法，它重复地遍历要排序的元素，比较相邻的两个元素大小，并根据大小交换位置，直到没有任何一对数字需要...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值