C实现单链表常用操作及与数组相互格式转换

最新推荐文章于 2023-08-14 18:13:41 发布

Swair_Fang

最新推荐文章于 2023-08-14 18:13:41 发布

阅读量2.6k

点赞数 1

CC 4.0 BY-SA版权

分类专栏： C/C++

本文链接：https://blog.youkuaiyun.com/swairf/article/details/19615797

C/C++ 专栏收录该内容

22 篇文章

订阅专栏

本文介绍了一种单链表的数据结构实现方法，并提供了多种实用功能，包括链表的初始化、数组与链表间的转换、查找、删除、插入等操作。此外，还实现了链表的快速排序算法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

/*
 ============================================================================
 Name        : 单链表（带表头L）
 Author      : Swair Fang
 Version     : 1.1
 Copyright   : by Swair Fang
 Description : 堆内单链表实现,与栈内数组相互格式转换等功能， Ansi-style
 功能：
 	 1.链表初始化,若控制台输入遇到-1结束,或者自动生成一数列
 	 2.数组转换为链表
 	 3.链表转换为数组
 	 4.删除链表
 	 5.查找X
 	 6.查找X的前驱元素
 	 7.删除X
 	 8.在P位置后插入X
 	 9.插入操作，默认插入到第一个位置
 	 10.返回链表长度
 	 11.打印链表
	 12.打印节点地址
	 13.获得第N个节点的地址,第0个为表头L
	 14.链表快速排序
 ============================================================================
 */
#include 
#include 

#ifndef _List_H
#define _List_H
typedef int ElementType;

//构建节点
typedef struct Node
{
	ElementType Element;
	struct Node *Next;
} *List,*Position;

//1.链表初始化,若控制台输入遇到-1结束,或者自动生成一数列
List InitList()
{
	List L=(List)malloc(sizeof(struct Node));
	if(L==NULL)
	{
		printf("Out of Space!!!");
		exit(1);
	}
	L->Next=NULL;
	Position P=L;
	Position Tmp;

	printf(" Input char to select mode: i or n?\n");
	char mode;
	scanf("%c",&mode);
	if(mode=='i')
	{
		while(1)
		{
			ElementType indata;
			scanf("%d",&indata);
			if(indata==-1)
				break;
			Tmp=(Position)malloc(sizeof(struct Node));
			Tmp->Element=indata;
			Tmp->Next=NULL;
			P->Next=Tmp;
			P=P->Next;
		}
	}
	else
	{
		int i=0;
		while(i<10)
		{
			Tmp=(Position)malloc(sizeof(struct Node));
			Tmp->Element=10-i;
			Tmp->Next=NULL;
			P->Next=Tmp;
			P=P->Next;
			i++;
		}
	}
	return L;
}
//2.数组转换为链表
List Array2List(const ElementType *Ay,int Size)
{
	List L=(List)malloc(sizeof(struct Node));
	if(L==NULL)
	{
		printf("Out of Space!!!");
		exit(1);
	}
	L->Next=NULL;
	Position P=L;
	Position Tmp;
	int i=0;
	while(iElement=Ay[i];
		Tmp->Next=NULL;
		P->Next=Tmp;
		P=P->Next;
		i++;
	}
	return L;
}
//3.链表转换为数组
void List2Array(List L,int Size,ElementType *Ay)
{
	Position P=L->Next;
	int i=0;
	while(iElement;
		P=P->Next;
		i++;
	}
}
//4.删除链表
void DeleteList(List L)
{
	Position P,Tmp;
	P=L->Next;
	L->Next=NULL;
	while(P!=NULL)
	{
		Tmp=P->Next;
		free(P);
		P=Tmp;
	}
	free(L);
}
//5.查找X
Position Find(List L,ElementType X)
{
	Position P;
	P=L->Next;
	while(P!=NULL&&P->Element!=X)
		P=P->Next;
	if(P==NULL)
		printf("链表中无%d这个数\n",X);
	return P;
}
//6.查找X的前驱元素
Position FindPrevious(List L,ElementType X)
{
	Position P;
	P=L;
	while(P->Next!=NULL&&P->Next->Element!=X)
		P=P->Next;
	return P;
}
//7.删除X
void Delete(List L,ElementType X)
{
	Position P,TmpCell;
	P=FindPrevious(L,X);
	if(P->Next!=NULL)
	{
		TmpCell=P->Next;
		P->Next=P->Next->Next;
		free(TmpCell);
	}
}
//8.在P位置后插入X
void PInsert(List L,Position P,ElementType X)
{
	Position TmpCell=(Position)malloc(sizeof(struct Node));
	if(TmpCell==NULL)
	{
		printf("Out of Space!!!");
		exit(1);
	}
	TmpCell->Element=X;
	TmpCell->Next=P->Next;
	P->Next=TmpCell;
}
//9.插入操作，默认插入到第一个位置
void Insert(List L,ElementType X)
{
	Position TmpCell=(Position)malloc(sizeof(struct Node));
	TmpCell->Element=X;
	TmpCell->Next=L->Next;
	L->Next=TmpCell;
}
//10.返回链表长度
int SizeList(List L)
{
	int size=0;
	Position P=L->Next;
	while(P!=NULL)
	{
		P=P->Next;
		size++;
	}
	return size;
}
//11.打印链表
void PrintList(List L)
{
	if(L==NULL||L->Next==NULL)
		printf("链表为空\n");
	else
	{
		Position P=L->Next;
		while(P!=NULL)
		{
			char *cp=(char*)P;
			printf("0x%x: %d\n  ",cp,P->Element);
			P=P->Next;
		}
		printf("\n");
	}
}
//12.打印节点地址
void PrintPosition(Position P)
{
	if(P==NULL)
		printf("节点地址为空\n");
	else
	{
		char *cp=(char*)P;
		printf("0x%x:  %d\n  ",cp,P->Element);
	}
}
//打印数组
void PrintArray(ElementType *Ay,int Size)
{
	int i=0;
	while(iNext;
	return P;
}
//14.链表快速排序
void QuickSort(Position Head,Position Tail)
{
	if(Head->Next!=Tail&&Head->Next->Next!=Tail)
	{
		static int count;
		//	printf("QuickSort调用第%d次数\n",count++);
		Position KeyP=Head->Next;      //指向存key值内存单元的指针
		Position LP=Head;              //比key值小的游标指针,KeyP的左边
		Position RP=KeyP;              //比key值大的游标指针,KeyP的右边
		Position IncP=KeyP->Next;      //遍历单链表的游标指针,每次移动一位
		while(IncP!=Tail)
		{
			if(IncP->ElementElement)
				LP=LP->Next=IncP;
			else
				RP=RP->Next=IncP;
			IncP=IncP->Next;
		}
		LP->Next=KeyP;    //将小于Key值的子链表衔接
		RP->Next=Tail;    //将大于Key值的子链表衔接

		//递归
		QuickSort(Head,KeyP); //比Key小的子链表排序
		QuickSort(KeyP,Tail); //比Key大的子链表排序
		//注Head和Tail是不参与排序的，只起表头和表尾标识作用,故原链表的Tail值为NULL
	}
}
#endif/*_List_H*/

int main(void)
{
	printf("===============初始化链表===============\n");
	List L=InitList();
	PrintList(L);

	printf("===============插入165===============\n");
	Insert(L,165);
	PrintList(L);

	printf("===============链表长度为=============\n%d\n",SizeList(L));

	printf("===============快速排序===============\n");
	QuickSort(L,NULL);

	printf("===============排序后===============\n");
	PrintList(L);

	printf("===============查找7===============\n");
	Position P=Find(L,7);
	PrintPosition(P);

	printf("===============删除7===============\n");
	Delete(L,7);
	PrintList(L);

	printf("===============数组转换为链表===============\n");
	ElementType array[5]={2,3,4,1,6};
	int size=sizeof(array)/sizeof(array[0]);
	List La=Array2List(array,size);
	PrintList(La);

	printf("===============插入111,123===============\n");
	Insert(La,111);
	Insert(La,123);
	PrintList(La);

	printf("===============快速排序===============\n");
	QuickSort(La,NULL);
	PrintList(La);

	printf("===============查找4前一个节点的数===============\n");
	P=FindPrevious(La,4);
	PrintPosition(P);

	printf("===============删除4===============\n");
	Delete(La,4);
	PrintList(La);

	printf("===============链表转换为数组===============\n");
	int Size=SizeList(La);
	ElementType Ay[Size];
	List2Array(La,Size,Ay);
	PrintArray(Ay,Size);

	//删除链表
	DeleteList(L);
	DeleteList(La);
	exit(0);
}