单链表排序交换节点算法

最新推荐文章于 2024-04-03 17:07:45 发布
最新推荐文章于 2024-04-03 17:07:45 发布
阅读量5.8k 收藏 6
点赞数 3
分类专栏： C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ouchengguo/article/details/24195325
版权

单链表交换节点排序，包括选择法、比较法、排序法。

用C实现代码如下：

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#define TRUE 1
#define FALSE 0
#define ERROR 0
#define OVERFLOW 0
#define OK 1
typedef int Status;
typedef int ElemType;

struct LNode
{ 
	ElemType data;
	struct LNode *next;
};
typedef struct LNode LinkList;
LinkList *InitList(LinkList *L);/*初始化一个链表*/
void DestoryList(LinkList *L);/*销假链表*/
void ClearList(LinkList *L);/*清空链表 */
Status ListEmpty(LinkList *L);/*判断链表是否为空 */
int ListLength(LinkList *L);/*返回表的长度  */
Status GetElem(LinkList *L,int i,ElemType *e);/*返回第i个元素的值 */
int LocateElem(LinkList *L,ElemType e,Status(*compare)(ElemType));/*返回L中第1个与e满足关系compare()的数据元素的位序*/
Status PriorElem(LinkList *L,ElemType cur_e,ElemType *pre_e);/*返回前驱的值 */
Status NextElem(LinkList *L,ElemType cur_e,ElemType *next_e);/*返回后继的值*/
Status ListInsert(LinkList *L,int i,ElemType e);/*在带头结点的单链表中第i个位置之前插入元素e*/
Status ListDelete(LinkList *L,int i,ElemType *e);/*在带头结点的单链表中，删除第1个元素，用e返回其值勤*/
void ListTraverse(LinkList *L,void(*visit)(ElemType));/*依次对L的每个元素调用函数visit() */
void print(ElemType e);
Status equal(ElemType c1,ElemType c2);
void Listprint(LinkList *L);
void Merge(LinkList *La,LinkList *Lb);/*两个集合的交集 */
void Merge1(LinkList *La,LinkList *Lb);/*利用函数实现集合的交集*/
/*void Differ(LinkList La,LinkList Lb); *//*两个集合的差集        */
void Union1(LinkList *La,LinkList *Lb);/*利用函数实现集合的并集   */
void Differ(LinkList *La,LinkList *Lb);/*利用函数实现集合的差集   */

LinkList *InitList(LinkList *L)/*构造一个空链链表*/
{ 
	L=(LinkList*)malloc(sizeof(LinkList));/*产生头结点,并使L指向此头结点*/
	if(L==NULL) exit(OVERFLOW);
	L->next=NULL;
	return L;
}
void DestroyList(LinkList *L)/*销毁L*/
{  
	LinkList *q;
	while(L!=NULL)/*L指向结点*/
	{ 
		q=L->next;/*q指向首元结点*/
		free(L);
		L=q;/*L指向原首结点*/
	}
}
void ClearList(LinkList *L)
{ /*将表清空 */
	LinkList *p=L->next;
	L->next=NULL;
	DestroyList(p);/*销毁P所指向的单链表 */
}
Status ListEmpty(LinkList *L)
{ /*表为空则返回TRUE，否则返回FALSE */
	if(L->next!=NULL) return FALSE;
	else return TRUE;
}
int ListLength(LinkList *L)
{/*返回表中的元素的个数*/
	int i=0;
	LinkList *p=L->next;/*P指向第一个结点*/
	while(p!=NULL)/*未到表尾*/
	{ 
		i++;
		p=p->next;
	}
	return i;
}

Status GetElem(LinkList *L,int i,ElemType *e)/*当第i个元素存在时，将其值赋给e */
{
	int j=1;/*计数器初值为1*/
	LinkList *p=L->next;/*p指向第一个结点*/
	while((p!=NULL)&&(j<i))/*顺指针向后查找，直到找到p指向第i个结点*/
	{
		j++;
		p=p->next;
	}
	if((p==NULL)||(j>i)) return ERROR;/*p==NULL说明L中节点数目小于i，若j>i成立，则必有i<1时，i越界*/
	(*e)=p->data;
	return OK;
}
int LocatElem(LinkList *L,ElemType e,Status(*compare)(ElemType,ElemType))
{   /*返回表中第1个数据域与e满足关系compare()的数据关系的节点的位序 */
	int i=0;/*计数器初值为0 */
	LinkList *p=L->next;
	while(p!=NULL)/*未到表尾   */
	{
		i++;
		if(compare(p->data,e))/*找到这样的元素*/
			return i;/*返回其位序*/
		p=p->next;
	}
	return 0;/*不存在相应节点*/
}
Status PriorElem(LinkList *L,ElemType cur_e,ElemType *pre_e)
{ /*返回前驱 */
	LinkList *q,*p=L->next;/*p指向第一个元素*/
	while(p->next!=NULL)/*p指的结点有后继 */
	{ 
		q=p->next;/*q指向p的后继   */
		if(q->data==cur_e)/*p的后继为cur_e  */
		{ 
			(*pre_e)=p->data;
			return OK;
		}
		p=q;/*p的后继不为cur_e,向后移*/
	}
	return ERROR;
}
Status NextElem(LinkList *L,ElemType cur_e,ElemType *next_e)
{ /*返回后继 */
	LinkList *p=L->next;
	while(p->next!=NULL)/*p所指结点的后继 */
	{ 
		if(p->data==cur_e)  
		{
			(*next_e)=p->next->data;
			return OK;
		}
		p=p->next;
	}
	return ERROR;
}

Status ListInsert(LinkList *L,int i,ElemType e)
{ 
	/*在第i个位置之前插入元素e */
	int j=0;/*计数器初值为0*/
	LinkList *s,*p=L;/*p指向头结点*/
	while((p!=NULL)&&(j<i-1))/*寻找第i个结点*/
	{ 
		j++;
		p=p->next;
	}
	if((p==NULL)||(j>i-1)) return ERROR;/*p==NULL说明L中节点数目小于i，若j>i成立，则必有i<1时，i越界*/
	s=(LinkList*)malloc(sizeof(LinkList));/*生成新的结点*/
	s->data=e;
	s->next=p->next;/*新结点指向原第i个结点*/
	p->next=s;/*原第i-1个结点指向新结点*/
	return OK;
}
Status ListDelete(LinkList *L,int i,ElemType *e)
{/*在带头结点的单链表中删除第i个元素，并用e返回其值*/
	int j=0;/*计数器初值为0*/
	LinkList *q,*p=L;/*p指向头结点*/
	while((p->next!=NULL)&&(j<i-1))/*寻找第i个结点，并用p指向其前驱*/
	{
		j++;
		p=p->next;
	}
	if((p->next==NULL)||(j>i-1)) return ERROR;/*p->next==NULL说明L中节点数目小于i，若j>i成立，则必有i<1时，i越界*/
	q=p->next;
	p->next=q->next;
	(*e)=q->data;
	free(q);
	return OK;
}

void ListTreaverse(LinkList *L,void(* visit)(ElemType))
{/*依次对L的每个数据元素调用函数visit()*/
	LinkList *p=L->next;/*p指向第一个元素 */
	while(p)
	{
		visit(p->data);
		p=p->next;
	}
	printf("\n");
}

Status equal(ElemType c1,ElemType c2)
{  /*判断两个数是否相等 */
	if(c1==c2)
		return TRUE;
	else
		return FALSE;
}
void print(ElemType e)
{ 
	printf("%d",e);
}

void Listprint(LinkList *L)/*输出单链表*/
{  
	LinkList *p=L->next;
	while(p!=NULL)
	{  
		printf("%d",p->data);
		p=p->next;
	}
	printf("\n");
}

void Merge(LinkList *La,LinkList *Lb)/*两个集合的交集*//*存在错误小缺陷,,重复元素的问题*/
{  
	LinkList *pa,*pb;
	/*pa=La->next; */
	/*pb=Lb->next;*/
	for(pa=La;pa->next!=NULL;pa=pa->next)
		for(pb=Lb->next;pb->next!=NULL;pb=pb->next)
		{
			if(pa->data==pb->data)
				printf("%d",pa->data);
		}
}

void Merge1(LinkList *La,LinkList *Lb)/*利用函数实现集合的交集*/
{
	ElemType e=0;
	int La_len,Lb_len;
	int i;
	La_len=ListLength(La);
	Lb_len=ListLength(Lb);
	for(i=1;i<=Lb_len;i++)
	{
		GetElem(Lb,i,&e);
		if(LocatElem(La,e,equal))
			printf("%d",e);
	}
}


void Union1(LinkList *La,LinkList *Lb)/*利用函数实现集合的并集*/
{ 
	ElemType e=0;
	int La_len,Lb_len;
	int i;
	La_len=ListLength(La);
	Lb_len=ListLength(Lb);
	for(i=1;i<=Lb_len;i++)
	{
		GetElem(Lb,i,&e);/*取表中第i个元素赋给e */
		if(LocatElem(La,e,equal)==0)/*表La中不存在和e相同的元素*/
			ListInsert(La,++La_len,e);/*在表la中插入元素e */
	}
	Listprint(La);
}

void Differ(LinkList *La,LinkList* Lb)/*利用函数实现集合的差集 */
{
	ElemType e=0;
	int La_len,Lb_len;
	int i;
	La_len=ListLength(La);
	Lb_len=ListLength(Lb);
	for(i=1;i<=La_len;i++)
	{ 
		GetElem(La,i,&e);/*取表中第i个元素赋给e */
		if(LocatElem(Lb,e,equal)==0)/*表Lb中不存在这样的元素 */
			printf("%d",e);
	}
}
void main()
{  
	LinkList *L,*La,*Lb;
	int i=0,k=0,j=0,e1=0,e=0;
	L=NULL;
	La=NULL;
	Lb=NULL;
	L=(LinkList*)malloc(sizeof(LinkList));
	L=InitList(L);/*初始化链表 */
	k=ListEmpty(L);
	printf("L为空表?k=%d(k=1,是;k=0,否)",k);
	printf("\n");
	for(i=1;i<=5;i++)
		ListInsert(L,1,i);
	printf("线性表为L=");
	/*ListTraverse(L,print);*/
	Listprint(L);
	printf("\n表的长度为%d\n",ListLength(L));
	/*删除元素 */
	k=ListDelete(L,3,&e);
	if(k==ERROR)  
		printf("删除不成功");
	else 
		printf("删除元素成功，其值为%d",e);
	printf("\n");
	/*判断表是否为空 */
	k=ListEmpty(L);
	printf("L为空表?k=%d(k=1,是;k=0,否)",k);
	printf("\n");
	/*清空表后*/
	ClearList(L);/*清空表 */
	printf("表清空后长度为%d",ListLength(L));
	Listprint(L);
	/*再次判断表是否为空*/
	k=ListEmpty(L);
	printf("L为空表?k=%d(k=1,是;k=0,否)",k);
	printf("\n");
	for(j=1;j<=10;j++)
		ListInsert(L,j,j);/*在L的表尾插入j */
	printf("重新插入元素之后表变为:");
	Listprint(L);
	/*判断前驱*/
	for(j=1;j<=ListLength(L);j++)
	{
		GetElem(L,j,&e);/*把L中第j个元素赋给e */
		k=PriorElem(L,e,&e1);/*求e的前驱，并赋给e1*/
		if(k==ERROR)
			printf("元素%d无前驱\n",e);
		else
			printf("元素%d的前驱为%d\n",e,e1);
	}
	printf("\n");
	/*判断后继*/
	for(j=1;j<=ListLength(L);j++)
	{ 
		GetElem(L,j,&e);/*把L中第j个元素赋给e*/
		k=NextElem(L,e,&e1);/*求e的前驱，并赋给e */
		if(k==ERROR)
			printf("元素%d无后继\n",e);
		else 
			printf("元素%d的后继为%d\n",e,e1);
	} 
	/*两个单链表的操作*/
	La=InitList(La);
	for(i=1;i<=5;i++)
		ListInsert(La,i,i);
	printf("单链表La:");
	Listprint(La);
	printf("\n");
	Lb=InitList(Lb);
	for(i=1;i<=5;i++)
		ListInsert(Lb,i,2*i);
	printf("单链表Lb:");
	Listprint(Lb);
	printf("\n");
	/*两个集合的交集*/
	printf("两个集合的交集:");
	Merge(La,Lb);
	printf("\n");
	/*利用函数实现集合的交集 */
	printf("利用函数实现集合的交集:");
	Merge1(La,Lb);
	printf("\n");
	/*两个集合的差集 */
	printf("利用函数实现集合的差集La-Lb:");
	Differ(La,Lb);
	printf("\n");
	/*两个集合的并集*/
	printf("两个集合的并集:");
	Union1(La,Lb);
	getch();
}


ladder_of_love
关注
  • 3
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
使用单向链表进行交换排序
zhouyinuo1998的博客
11-10 744
思路 1、使用单向链表； 2、排序时只交换节点中的元素，不改变节点的位置。 3、排序采用冒泡排序的方法。 重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。 注意： <1> 每经过一轮的排序，一个最大的元素被“浮”到对应的位置。随之，下一次比较的终点也需要向前移一个元素。 <2> 当正数第二个元素被确定的时候，冒
单链表上的简单选择排序算法
06-04
总之，单链表上的简单选择排序算法是对原始算法的一种适应，它利用链表的特性来找到最小元素并进行交换。虽然效率不高，但对于理解链表和排序算法的基本原理很有帮助。在实际应用中，通常会使用更高效的排序算法，如...
单链表排序（交换节点）
weixin_48755527的博客
08-19 2201
单链表排序（移动节点） 单链表排序利用了选择排序的方式； 创建一个单链表结构体 typedef int data_t;//为了能适应存储其他类型数据，可以将int换成其他数据类型而不通用一个一个更改程序里的了 typedef struct node{ data_t a;//链表里存的数据 struct node *next;//指向下一个节点 }linknode,* linklist;//创建结构体变量和指针 单链表节点的结构形式出来啦，接下来我们就按图施工，创建链表吧 linklist link_
算法_交换链表中的节点
最新发布
weixin_55955132的博客
04-03 350
给定⼀个链表，两两交换其中相邻的节点（不交叉），并返回交换后的链表。你不能只是单纯的改变节点内部的值，⽽是需要。原链表：1->2->3->4输出链表：2->1->4->3。
单链表冒泡排序（交换节点）
weixin_34126557的博客
07-24 1393
代码如下： #include<iostream> #include<cstdlib> using namespace std; int num; typedef struct list { int data; struct list *next; }Lnode,*linklist; linklist Createlist(int n)...
单链表的排序
weixin_43411789的博客
06-07 265
单链表排序 单链表节点交换 单链表节点交换原理
深入单链表的快速排序详解
09-05
当找到需要交换的元素时，只需调整指针的链接关系即可，不需要实际交换节点对象。 下面是一个简单的单链表快速排序的实现示例： ```cpp // 定义链表节点 struct SList { int data; SList* next; }; // 构建链表...
C++单链表选择排序
12-18
当内层循环结束后，将`minNode`的值与`head`交换，这样`head`就成为新的已排序部分的起始节点。然后，我们移动`head`到下一个未排序的节点，重复这个过程，直到整个链表排序完成。 在实际编程中，`sort.cpp`和`sort...
单链表实现从小到大排序
05-24
上述`sort_list`方法采用了简单的冒泡排序算法，通过比较相邻节点并交换位置来实现排序。然而，链表的冒泡排序效率较低，因为每次比较都需要遍历整个链表。在实际应用中，更高效的排序算法如快速排序或归并排序可能...
C++单链表操——作交换节点
u011832277的专栏
08-26 3190
链表是最为常见，并且经常需要使用到的数据结构之一。对于单链表的基本操作，例如创建链表、插入、删除等都不是特别复杂，但是其实对于链表的操作实际上很多的操作还是有一定的难度，例如上次给出的单链表的逆转，以及这里的单链表交换两个节点。 　　单链表的交换节点的含义是：给定一个单链表，要求交换其中的任意两个节点。注意这里链表的头节点是不参与节点交换的。这个看上去是比较简单，但是实现起来却还是需要一定的基本
几种排序算法的实现（链表）
07-11
通过链表实现几种排序算法，并比较它们的优劣。
单链表进行排序-通过节点交换，不通过值交换
热门推荐
04-20 1万+
原来我一直都不会对链表进行排序，呵呵，比较菜。今天下了很大的功夫学习对链表的排序，和大家分享一下！         对链表的排序主要有两种方法：         一：只交换节点中的元素，不改变链表的顺序。        二：直接交换节点，不改变节点中的元素。         其中交换节点是最麻烦的，稍不注意就会出错！而交换节点中的元素还是比较简单的。用几个swap( )就可
两种方法实现链表的节点操作排序
04-21 4871
题目： 功能: 根据单向链表的节点值和排序标识进行升降排序，并返回排序后的链表头指针。 输入: ListNode* pListHead  单向链表 unsigned int uiSortFlag  0表示按升序，1表示按降序 输出: 无 返回: 排序成功返回链表头指针，异常或未进行排序返回空指针   说明：通过四个指针实现两个节点的交换，也即要保持该交换的节点的
【数据结构】对单链表进行简单选择排序，使结点元素递增
每天进步一点丶的博客
02-20 3033
文章目录1.算法思想2.定义结构体3.函数实现4.测试用例5.完整代码 1.算法思想 循环创建单链表 使用简单选择排序找到当前最小的结点的值 交换最小值与当前值 重复2，3两步，直到排序完成 2.定义结构体 只使用到单链表的数据结构: data: 存放数据元素 next: 用于指向下一个结点的指针 typedef struct LNode { int data; struct LNode *next; } LNode, *LinkList; 3.函数实现 工作指针： min: 指
C链表选择排序(交换节点排序)
m0_46254928的博客
11-12 1448
排序函数的代码如下： void select_sort(struct node* head)//选择排序（升序） { struct node* pre = head; struct node* p = pre->next; struct node* bmin = pre, * min, * lmin;//bmin是min前一个节点，lmin是min后一个节点 struct node* bq, * q; //bq记录q的前一个节点 while (p->next)//至少要有两个数才会进
链表的结点排序-13编程题
qq_43389032的博客
11-25 593
构造一个链表：该链表包含两个整数，将所有结点按照第一个整数从小到大排序，如第一个整数相同，则按照第二个整数从小到大排序 #include <stdio.h> #include <stdlib.h> typedef struct LNode { int data1,data2; struct LNode *next; }LNode,*LinkList; bool InitList(LinkList &L) { //LinkList L; L=
第二章 链表 节点排序
Cgxxxxxxxxxxxxxx的博客
01-20 374
#include <stdio.h> #include <stdlib.h> using namespace std; typedef struct LinkedList{ int data; struct LinkedList *next; }LinkedList,*List; int a[6]={3,2,5,4,1,6}; int n=6; void build(List &L){ L=(List)malloc(sizeof(LinkedLi...
链表交换、排序、相加
much efforts, much luck
06-16 934
链表交换和排序 1、给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。 示例: 给定 1->2->3->4, 你应该返回 2->1->4->3. 说明: 你的算法只能使用常数的额外空间。 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 1 class Solution { 2 public: 3 ListNode* swapPairs(ListNode* head) { 4 ListNode *dummy = n
单链表排序算法从小到大
06-06
单链表排序算法从小到大的基本思路是：使用冒泡排序或选择排序等排序算法对链表中的元素进行排序，然后重新组织链表连接顺序。 下面是单链表排序的实现代码（使用冒泡排序）： ```csharp public static Node ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值