C/C++两个版本实现单链表

最新推荐文章于 2025-03-19 14:57:44 发布
最新推荐文章于 2025-03-19 14:57:44 发布
阅读量301 收藏 4
点赞数
分类专栏： C/C++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/hhmy77/article/details/89231939
版权
本文详细介绍了一个全面的链表操作集合，包括链表的创建、排序、逆转、删除重复元素及特定值、插入节点等核心功能，并提供了C和C++两个版本的实现代码，适合初学者和开发者快速掌握链表的基本操作。

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

文章目录

前言

写的时候注意一下C++和C的区别，C++里面new 和重载等在C中是没有的。基本上我能想到的函数都实现了

c语言中不能重载函数的原因

代码功能

功能一览

1.头插法建表
1.1直接读输入建表
1.2从文件中读路径建表
2.尾插法建表 同上
3.链表逆转，提供两种实现方法
4.链表排序，使用插入排序思想
4.1递增
4.2递减
5.输出
5.1正序
5.2逆序
6.删除链表中值为X的结点
7.删除值重复结点
8.删除最值
8.1最大值
8.2最小值
9.插入结点
9.1头插
9.2尾插

c++版

读入路径需要自己输入路径读入数据，写入路径直接初始化默认路径了。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
/*功能一览
1.头插法建表
	1.1直接读输入建表
	1.2从文件中读路径建表 
2.尾插法建表 
	同上
3.链表逆转，提供两种实现方法 
4.链表排序，使用插入排序思想
	4.1递增
	4.2递减 
5.输出
	5.1正序
	5.2逆序
6.删除链表中值为X的结点
7.删除值重复结点
8.删除最值
	8.1最大值
	8.2最小值
9.插入结点
	9.1头插 
	9.2尾插 
*/
typedef struct node
{
	int val;
	node* next;
}Node,*List;

//文件路径 用于读取 
//G:\\CppCode\\Data Structure\\experiment\\Readtest.txt 
char road[100]="G:\\CppCode\\Data Structure\\experiment\\Readtets2.txt";
FILE* fp;
FILE* wp=fopen("G:\\CppCode\\Data Structure\\experiment\\outPut.txt","w"); 
//尾插法建表 直接读取 
List endCreat()
{
	List H=(Node*)malloc(sizeof(Node));
	Node* q=H;
	Node* t;
	while(1)
	{
		char i=getchar();
		if(i=='\n')break;
		t=(List)malloc(sizeof(Node));
		t->next=NULL;
		t->val=i-'0';
		q->next=t;
		q=t;
	}
	return H;
}
//传路径读取 
List endCreat(FILE *fp)
{
	List H=(Node*)malloc(sizeof(Node));
	Node* q=H;
	Node* t;
	while(1)
	{
		char i=fgetc(fp);
		if(i==EOF)break;
		t=(List)malloc(sizeof(Node));
		t->next=NULL;
		t->val=i-'0';
		q->next=t;
		q=t;
	}
	return H;
}
//从路径里面读文件，这里要传入fp的引用 否则读取不了 
void readRoad(FILE*& fp)
{
	gets(road);
	fp=fopen(road,"r");

}
//往路径里面写文件 
void writeRoad(List& H,FILE*& wp)
{
	Node* p=H->next;
	while(p)
	{
		fputc(p->val+'0',wp);
		p=p->next;
	}
}
//头插法建表 
List frontCreat()
{
	List L=(Node*)malloc(sizeof(Node));
	L->next=NULL;
	Node *t;
	while(1)
	{
		char i=getchar();
		if(i=='\n')break;
		t=(Node*)malloc(sizeof(Node));
		t->val=i-'0';
		t->next=L->next;
		L->next=t;
	}
	return L;
}
//在尾端插入 
void insertEnd(List& H,int x)
{
	Node* p=H;
	while(p->next)
	{
		p=p->next;
	}
	Node* t=(Node*)malloc(sizeof(Node));
	t->val=x;
	t->next=NULL;
	p->next=t;
}
//头结点插入 
void insertStart(List& H,int x)
{
	Node* t=(Node*)malloc(sizeof(Node));
	t->val=x;
	t->next=H->next;
	H->next=t;
}

//传引用修改链表
//口->1->2->3->2->4 
//口->1->3->4
//从头分析 当传入头结点时它不等于任何值,所以传入H->next到下一层递归
//在下一层递归如果等于X,那么修改链表H->next=H->next->next; 
void delX(List& H,int X)
{
	Node* p;
	if(!H)return ;
	if(H->val==X)
	{
		p=H;
		H=H->next;
		free(p);
		delX(H,X);
	}
	else delX(H->next,X);
}
//链表逆转 摘下头结点然后再用前插法建表 
void Reverse(List H)
{
	Node* p=H->next;
	H->next=NULL;
	Node* q=p->next;
	while(p)
	{
		q=p->next;
		p->next=H->next;
		H->next=p;
		p=q;
	}
}
//链表逆转2 新建空节点
//不断取头结点的下一个结点指向新节点
void Reverse2(List& H)
{
	Node* t=NULL;
	Node* p=H->next;
	Node* q=p->next;
	while(p)
	{
		q=p->next;
		p->next=t;
		t=p;
		p=q;
	}
	H->next=t;
} 
void Print(List H)
{
	List p=H->next;
	int i=0;
	while(p)
	{
		printf("%s%d",i==0?"":"->",p->val);
		i=1;
		p=p->next;
	}
	printf("\n");
}
//递归逆序输出链表的值 
void Print_d(List H)
{
	if(H->next)
	{
		Print_d(H->next);
	}
	printf("%d",H->val);
	return;
} 
//按值递增排序链表
void sortListAsc(List& H)
{
	Node* p=H->next;
	Node* t=p->next;
	p->next=NULL;
	p=t;
	Node* r;
	while(p)
	{
		t=p->next;
		r=H;
		while(r->next)
		{
			if(r->next->val>p->val)break;
			r=r->next;
		}
		p->next=r->next;
		r->next=p;
		p=t;
	}
}
//升序排列链表 
void sortListDec(List& H)
{
	Node* p=H->next;
	Node* t=p->next;
	p->next=NULL;
	p=t;
	Node* r;
	while(p)
	{
		t=p->next;
		r=H;
		while(r->next)
		{
			if(r->next->val<p->val)break;
			r=r->next;
		}
		p->next=r->next;
		r->next=p;
		p=t;
	}
}
//删除重复 
void delRepe(List &H)
{
	if(!H->next)return ;
	const int len=1000;
	int book[len];
	memset(book,0,sizeof(int)*len);
	Node* p=H;
	Node* q;
	while(p->next)
	{
		if(book[p->next->val]==0)
		{
			book[p->next->val]=1;
			p=p->next;
		}
		else
		{
			q=p->next;
			p->next=p->next->next;
			free(q);
		}
	}
}
bool delMin(List H)
{
	if(!H->next)return 0;
	Node* p=H;
	Node* q=H;
	int min=H->next->val;
	while(p->next)
	{
		if(p->next->val<min)
		{
			min=p->next->val;
			q=p;
		}
		p=p->next;
	}
	p=q->next;
	q->next=q->next->next;
	free(p);
	return 1;	
}
bool delMax(List H)
{
	if(!H->next)return 0;
	Node* p=H;
	Node* q=H;
	int Max=H->next->val;
	while(p->next)
	{
		if(p->next->val>Max)
		{
			Max=p->next->val;
			q=p;
		}
		p=p->next;
	}
	p=q->next;
	q->next=q->next->next;
	free(p);
	return 1;	
}

int main()
{
	List Head;
	int i=0;
	//G:\\CppCode\\Data Structure\\experiment\\Readtets2.txt 
	printf("请先建表，1输入路径读取，2直接读取:");
	scanf("%d",&i);
	switch(i)
	{
		case 1:
			getchar();
			readRoad(fp);
			Head=endCreat(fp);
			break;
		case 2:
			getchar();
			Head=endCreat();
			break;
	}
	int ch=0;
	int t=0;
	bool end=false;
	while(1)
	{
		if(end)break;
		printf("------menu------\n");
		printf("1.printf\n");
		printf("2.reverse\n");
		printf("3.delX\n");
		printf("4.delMin\n");
		printf("5.delMax\n");
		printf("6.delRepe\n");
		printf("7.insert at end\n");
		printf("8.sort descend\n");
		printf("9.write road\n");
		printf("-1.end\n");
		scanf("%d",&ch);
		switch(ch)
		{
			case 1:
				Print(Head);
				break;
			case 2:
				Reverse(Head);
				Print(Head); 
				break;
			case 3:
				printf("x:");
				scanf("%d",&t);
				delX(Head,t);
				Print(Head); 
				break;
			case 4:
				delMin(Head);
				Print(Head); 
				break;
			case 5:
				delMax(Head);
				Print(Head); 
				break;
			case 6:
				delRepe(Head);
				Print(Head); 
				break;
			case 7:
				printf("x:");
				scanf("%d",&t);
				insertEnd(Head,t);
				Print(Head); 
				break;
			case 8:
				sortListAsc(Head);
				Print(Head); 
				break;
			case 9:
				writeRoad(Head,wp);
				break;
			case -1:
				end=true;
				break;
		}
		if(!Head->next)printf("链表现在为空\n");
		printf("*****************\n");
	}
	return 0;
}

c版本

重命名了重载函数，稍微修改了下读写函数，还有就是好像不支持传指针引用这种写法，直接把引用都去掉了，测试也没问题

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
/*功能一览
1.头插法建表
	1.1直接读输入建表
	1.2从文件中读路径建表 
2.尾插法建表 
	同上
3.链表逆转，提供两种实现方法 
4.链表排序，使用插入排序思想
	4.1递增
	4.2递减 
5.输出
	5.1正序
	5.2逆序
6.删除链表中值为X的结点
7.删除值重复结点
8.删除最值
	8.1最大值
	8.2最小值
9.插入结点
	9.1头插 
	9.2尾插 
*/
typedef struct node
{
	int val;
	struct node* next;
}Node,*List;

//文件路径 用于读取 
//G:\\CppCode\\Data Structure\\experiment\\Readtest.txt 
char road[100]="G:\\CppCode\\Data Structure\\experiment\\Readtets2.txt";
FILE* fp;
FILE* wp;
//尾插法建表 直接读取 
List endCreat()
{
	List H=(Node*)malloc(sizeof(Node));
	Node* q=H;
	Node* t;
	while(1)
	{
		char i=getchar();
		if(i=='\n')break;
		t=(List)malloc(sizeof(Node));
		t->next=NULL;
		t->val=i-'0';
		q->next=t;
		q=t;
	}
	return H;
}
//传路径读取 
List endCreatRoad(FILE *fp)
{
	List H=(Node*)malloc(sizeof(Node));
	Node* q=H;
	Node* t;
	while(1)
	{
		char i=fgetc(fp);
//		printf("%c\n",i);
		if(i==EOF)break;
		t=(List)malloc(sizeof(Node));
		t->next=NULL;
		t->val=i-'0';
		q->next=t;
		q=t;
	}
	return H;
}
//从路径里面读文件，这里要传入fp的引用 否则读取不了 
FILE* readRoad(FILE* fp)
{
	gets(road);
	fp=fopen(road,"r");
	return fp;
}
//往路径里面写文件 
void writeRoad(List H,FILE* wp)
{
	Node* p=H->next;
	while(p)
	{
		fputc(p->val+'0',wp);
		p=p->next;
	}
}
//头插法建表 
List frontCreat()
{
	List L=(Node*)malloc(sizeof(Node));
	L->next=NULL;
	Node *t;
	while(1)
	{
		char i=getchar();
		if(i=='\n')break;
		t=(Node*)malloc(sizeof(Node));
		t->val=i-'0';
		t->next=L->next;
		L->next=t;
	}
	return L;
}
//在尾端插入 
void insertEnd(List H,int x)
{
	Node* p=H;
	while(p->next)
	{
		p=p->next;
	}
	Node* t=(Node*)malloc(sizeof(Node));
	t->val=x;
	t->next=NULL;
	p->next=t;
}
//头结点插入 
void insertStart(List H,int x)
{
	Node* t=(Node*)malloc(sizeof(Node));
	t->val=x;
	t->next=H->next;
	H->next=t;
}

//传引用修改链表
//口->1->2->3->2->4 
//口->1->3->4
//从头分析 当传入头结点时它不等于任何值,所以传入H->next到下一层递归
//在下一层递归如果等于X,那么修改链表H->next=H->next->next; 
void delX(List H,int X)
{
	Node* p;
	if(!H)return ;
	if(H->val==X)
	{
		p=H;
		H=H->next;
		free(p);
		delX(H,X);
	}
	else delX(H->next,X);
}
//链表逆转 摘下头结点然后再用前插法建表 
void Reverse(List H)
{
	Node* p=H->next;
	H->next=NULL;
	Node* q=p->next;
	while(p)
	{
		q=p->next;
		p->next=H->next;
		H->next=p;
		p=q;
	}
}
//链表逆转2 新建空节点
//不断取头结点的下一个结点指向新节点
void Reverse2(List H)
{
	Node* t=NULL;
	Node* p=H->next;
	Node* q=p->next;
	while(p)
	{
		q=p->next;
		p->next=t;
		t=p;
		p=q;
	}
	H->next=t;
} 
void Print(List H)
{
	List p=H->next;
	int i=0;
	while(p)
	{
		printf("%s%d",i==0?"":"->",p->val);
		i=1;
		p=p->next;
	}
	printf("\n");
}
//递归逆序输出链表的值 
void Print_d(List H)
{
	if(H->next)
	{
		Print_d(H->next);
	}
	printf("%d",H->val);
	return;
} 
//按值递增排序链表
void sortListAsc(List H)
{
	Node* p=H->next;
	Node* t=p->next;
	p->next=NULL;
	p=t;
	Node* r;
	while(p)
	{
		t=p->next;
		r=H;
		while(r->next)
		{
			if(r->next->val>p->val)break;
			r=r->next;
		}
		p->next=r->next;
		r->next=p;
		p=t;
	}
}
//升序排列链表 
void sortListDec(List H)
{
	Node* p=H->next;
	Node* t=p->next;
	p->next=NULL;
	p=t;
	Node* r;
	while(p)
	{
		t=p->next;
		r=H;
		while(r->next)
		{
			if(r->next->val<p->val)break;
			r=r->next;
		}
		p->next=r->next;
		r->next=p;
		p=t;
	}
}
//删除重复 
void delRepe(List H)
{
	if(!H->next)return ;
	const int len=1000;
	int book[len];
	memset(book,0,sizeof(int)*len);
	Node* p=H;
	Node* q;
	while(p->next)
	{
		if(book[p->next->val]==0)
		{
			book[p->next->val]=1;
			p=p->next;
		}
		else
		{
			q=p->next;
			p->next=p->next->next;
			free(q);
		}
	}
}
int delMin(List H)
{
	if(!H->next)return 0;
	Node* p=H;
	Node* q=H;
	int min=H->next->val;
	while(p->next)
	{
		if(p->next->val<min)
		{
			min=p->next->val;
			q=p;
		}
		p=p->next;
	}
	p=q->next;
	q->next=q->next->next;
	free(p);
	return 1;	
}
int delMax(List H)
{
	if(!H->next)return 0;
	Node* p=H;
	Node* q=H;
	int Max=H->next->val;
	while(p->next)
	{
		if(p->next->val>Max)
		{
			Max=p->next->val;
			q=p;
		}
		p=p->next;
	}
	p=q->next;
	q->next=q->next->next;
	free(p);
	return 1;	
}

int main()
{
	wp=fopen("G:\\CppCode\\Data Structure\\experiment\\outPut.txt","w"); 
	List Head;
	int i=0;
	//G:\\CppCode\\Data Structure\\experiment\\Readtets2.txt 
	printf("请先建表，1输入路径读取，2直接读取:");
	scanf("%d",&i);
	switch(i)
	{
		case 1:
			getchar();
			fp=readRoad(fp);
			Head=endCreatRoad(fp);
			break;
		case 2:
			getchar();
			Head=endCreat();
			break;
	}
	int ch=0;
	int t=0;
	int end=0;
	while(1)
	{
		if(end)break;
		printf("------menu------\n");
		printf("1.printf\n");
		printf("2.reverse\n");
		printf("3.delX\n");
		printf("4.delMin\n");
		printf("5.delMax\n");
		printf("6.delRepe\n");
		printf("7.insert at end\n");
		printf("8.sort descend\n");
		printf("9.write road\n");
		printf("-1.end\n");
		scanf("%d",&ch);
		switch(ch)
		{
			case 1:
				Print(Head);
				break;
			case 2:
				Reverse(Head);
				Print(Head); 
				break;
			case 3:
				printf("x:");
				scanf("%d",&t);
				delX(Head,t);
				Print(Head); 
				break;
			case 4:
				delMin(Head);
				Print(Head); 
				break;
			case 5:
				delMax(Head);
				Print(Head); 
				break;
			case 6:
				delRepe(Head);
				Print(Head); 
				break;
			case 7:
				printf("x:");
				scanf("%d",&t);
				insertEnd(Head,t);
				Print(Head); 
				break;
			case 8:
				sortListAsc(Head);
				Print(Head); 
				break;
			case 9:
				writeRoad(Head,wp);
				break;
			case -1:
				end=1;
				break;
		}
		if(!Head->next)printf("链表现在为空\n");
		printf("*****************\n");
	}
	return 0;
}
C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 10万+
C/C++学习路线总结与分享
C/C++数据结构之单链表
2301_80102396的博客
07-29 1503
显然这里要使得实参的头节点在链接一个节点，就是使得实参改变，它本身就是一个指针，所以形参我们就需要二级指针来接受实参，进行传址来改变实参。思路：头删比较简单，我们只需要把头节点的下一个节点用一个变量储存起来，然后我们把头节点释放，然后把头节点指向我们刚才变量存起来的那个地址即可；我们next是结构体类型指针，因为我们的next指向的是下一个节点，下一个节点也是结构体，所以我们需要使用结构体类型指针。在进行基本操作前提都是需要节点的，所以我们能将开辟节点的操作写为一个函数，这样在每次使用前调用即可。
c++实现的单链表
04-09
c++实现的单链表数据结构，供大家学习数据结构与算法使用
C++实现单链表
df737373的博客
07-20 153
单链表 相对于顺序表，多了一个next指针，用来连接数据，构成链式结构 下面是代码 #include<iostream> #include<assert.h> using namespace std; typedef int DataType; struct SListNode { SListNode* ...
链表--C++实现单链表
最新发布
star_star999的博客
03-19 414
对于顺序存储结构，最大的缺点就是：**插入** 和 **删除** 的时候需要移动大量元素，所以基于前人智慧发明了链表。祝同学们数据结构学习顺利！考研加油，Fighting！！！
单链表
SCUT 段九鼎(C/C++学生)
08-01 387
C++ 实现单链表
Slatter的博客
07-29 342
C++ 实现单链表 基本思路 首先创建一个结点类，在单链表中需要有头结点、尾结点、当前结点、结点数目，此处将head头结点定义为一个不带值的结点，同时将其下标设置为0，这样就做到了插入的是第几个元素，则该元素下标就是多少，curr指当前节点的前一个结点，这样方便结点的插入。 代码实现 #include <iostream> using namespace std; template <typename T> class Node { public: T value;
C/C++ 创建两个链表，实现两个链表高位到低位相加，并输出链表
hero_th的博客
04-01 999
效果图 链表结构体的定义 struct listnode { int data; listnode* next; listnode(int x) : data(x), next(NULL) {} }; 创建链表 void createlist(listnode* head, int i) { listnode* p; while (i--) { int value; printf("请输入节点值:"); scanf("%d", &value); listnode *p
C/C++合并两个单链表
07-06
合并两个单链表： 链表的创建，排序，合并
【C/C++】用单链表实现高精度加法
qq_60958172的博客
04-26 561
用C/C++单链表实现高精度加法
c/c++ 数据结构 单链表
2301_78564545的博客
06-21 698
创建方法二：依然是头插法，但是在赋值时将数组最后一个元素赋值给第一个创建的节点（创建完后是最后一个），将数组倒数第二个元素赋值给第二个创建的节点（创建完后是倒数第二个节点），以此类推。单链表的销毁：从头节点开始依次往后释放各个节点的内存，剩最后一个节点时退出循环，再将其free();求单链表的长度：每循环一次count+1，直到p为最后一个节点，返回count。根据单链表的元素值求索引：当索引小于单链表长度且存在该元素才返回，否则返回-1。根据单链表的索引取值：索引有效才为真，否则为假。
c++实现单链表
03-29
用c++实现单链表，单链表的每个结点的地址存放在其直接前驱结点的指针域中。其中第一个结点没有前驱结点，因此需要一个头指针指向第一个节点，便于我们对整个链表进行操作；这里的单链表的最后一个节点的指针域存放的是头结点的地址。 单链表不能随意存取，必要的时候我们可以通过已知结点的指针域不断遍历从而获取我们要的结点。
C/C++实现单向链表
01-16
分别用C和C++实现了单向链表（创建链表，插入数据、获取指定位置的数据、删除指定位置的数据...），如果在使用中觉得api不够用可以进行扩展；其中包含测试。
C++实现单链表（Single Linked List）
weixin_42133358的博客
05-14 8653
C++实现单链表（Single Linked List） 语言这个东西不用真的会忘， 我记得前前后后C++的基本语法我也看了好几遍了，一直没有动手写过什么东西，所以一遍遍的看，一遍遍的忘… … 正好最近在看数据结构，想着自己用C++来实现一下，一方面是熟悉整个逻辑过程，加深对数据结构的理解，另一方面，也熟悉一下C++。 单链表是线性表的链式存储结构，同顺序存储结构（可以理解为C++中的数组）不同的是，单链表在插入和删除一个结点时，不需要移动大量的元素，但是单链表没有数组中索引的概念，所以在查询一个元素
单链表（C++实现）
qq_39559641的博客
04-07 4074
一、实验要求 (1).尾插法创建单链表，打印创建结果。 (2).头插法创建单链表，打印创建结果。 (3).销毁单链表。 (4).求链表长度。 (5).求单链表中第i个元素（函数），若不存在，报错。 (6).在第i个结点前插入值为x的结点。 (7).链表中查找元素值为x的结点，成功返回结点指针，失败报错。 (8).删除单链表中第i个元素结点。 (9).在一个递增有序的单链表L中插...
单链表的实现(C++版)
05-12 9716
// 带头节点单链表的C++实现 #include "stdafx.h" #include #include using namespace std; class CNode //节点 { public: int data; CNode *next; CNode() { next=NULL; } }; class CLis
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值