数据结构学习（C语言）之链表代码

最新推荐文章于 2025-06-28 10:15:42 发布
翻译 最新推荐文章于 2025-06-28 10:15:42 发布 · 9.3k 阅读 · 119
文章标签：

#链表程序

本文深入讲解链表数据结构，涵盖链表的创建、遍历、排序、插入、删除等核心算法，通过具体代码实例帮助读者理解算法实现及泛型概念。

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

（郝斌老师视频课）

简介：

24_链表创建和链表遍历算法的演示
25_判断链表是否为空和求链表长度算法的演示
26_通过链表排序算法的演示再次详细讨论到底什么是算法以及到底什么是泛型【重点】
27_如何学习算法自己的一些感想
28_链表插入和删除算法的演示
29_复习

24_链表创建和链表遍历算法的演示

创建一个节点的结构体：

typedef struct Node
{
	int data;//数据域
	struct Node * pNext;//指针域
}NODE,*PNODE;//NODE等价于struct Node，PNODE等价于struct Node *

创建链表函数：

PNODE create_list(void)
{
	int len;//用来存放有效节点的个数
	int i;
	int val;//用来临时存放用户输入的节点的值

	//分配了一个不存放有效数据的头节点
	PNODE pHead=(PNODE)malloc(sizeof(NODE));
	if(NULL==pHead)
	{
		printf("分配失败，程序终止！\n");
		exit(-1);
	}
	PNODE pTail=pHead;
	pTail->pNext=NULL;
	printf("请输入您需要生成的链表节点的个数：len=");
	scanf("%d",&len);

	for (i=0;i<len;i++)
	{
		printf("请输入第%d个节点的值:",i+1);
		scanf("%d",&val);

		PNODE pNew=(PNODE)malloc(sizeof(NODE));
		if(NULL==pNew)
		{
			printf("分配失败，程序终止！\n");
			exit(-1);
		}
		pNew->data=val;//挂
		pTail->pNext=pNew;
		pNew->pNext=NULL;
		pTail=pNew;
	}
	return pHead;
}

链表遍历：

void traverse_list(PNODE pHead)
{
	PNODE p=pHead->pNext;
	while(NULL!=p)
	{
		printf("%d ",p->data);	
		p=p->pNext;//不连续，不能用p++
	}
	printf("\n");
	return;
}

测试：

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

typedef struct Node
{
	int data;//数据域
	struct Node * pNext;//指针域
}NODE,*PNODE;//NODE等价于struct Node，PNODE等价于struct Node *
//函数声明
PNODE create_list(void);
void traverse_list(PNODE pHead);

int main(void)
{
	PNODE pHead=NULL;//等价于struct Node *pHead=NULL；
	pHead=create_list();//creat_list()功能：创建一个非循环单链表,并将该链表的头节点的地址付给pHead
	traverse_list(pHead);
	return 0;
}

PNODE create_list(void)
{
	int len;//用来存放有效节点的个数
	int i;
	int val;//用来临时存放用户输入的节点的值

	//分配了一个不存放有效数据的头节点
	PNODE pHead=(PNODE)malloc(sizeof(NODE));
	if(NULL==pHead)
	{
		printf("分配失败，程序终止！\n");
		exit(-1);
	}
	PNODE pTail=pHead;
	pTail->pNext=NULL;
	printf("请输入您需要生成的链表节点的个数：len=");
	scanf("%d",&len);

	for (i=0;i<len;i++)
	{
		printf("请输入第%d个节点的值:",i+1);
		scanf("%d",&val);

		PNODE pNew=(PNODE)malloc(sizeof(NODE));
		if(NULL==pNew)
		{
			printf("分配失败，程序终止！\n");
			exit(-1);
		}
		pNew->data=val;//挂
		pTail->pNext=pNew;
		pNew->pNext=NULL;
		pTail=pNew;
	
	}
	return pHead;
}

void traverse_list(PNODE pHead)
{
	PNODE p=pHead->pNext;
	while(NULL!=p)
	{
		printf("%d ",p->data);	
		p=p->pNext;//不连续，不能用p++
	}
	printf("\n");
	return;
}

在这里插入图片描述

25_判断链表是否为空和求链表长度算法的演示

判断链表是否为空：

bool is_empty(PNODE pHead)
{
	if(pHead->pNext==NULL)
		return true;
	else
		return false;
}

求链表长度：

int length_list(PNODE pHead)
{
	PNODE p=pHead->pNext;
	int len=0;
	while(NULL!=p)
	{
		len++;
		p=p->pNext;
	}
	return len;
}

测试：

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

typedef struct Node
{
	int data;//数据域
	struct Node * pNext;//指针域
}NODE,*PNODE;//NODE等价于struct Node，PNODE等价于struct Node *
//函数声明
PNODE create_list(void);
void traverse_list(PNODE pHead);
bool is_empty(PNODE pHead);
int length_list(PNODE);
bool insert_list(PNODE,int,int);
bool delete_list(PNODE,int,int*);
void sort_list(PNODE);


int main(void)
{
	PNODE pHead=NULL;//等价于struct Node *pHead=NULL；
	pHead=create_list();//creat_list()功能：创建一个非循环单链表,并将该链表的头节点的地址付给pHead
	traverse_list(pHead);
	int len=length_list(pHead);
	printf("链表长度是%d\n",len);

	if(is_empty(pHead))
		printf("链表为空！\n");
	else 
		printf("链表不空！\n");

	return 0;
}

PNODE create_list(void)
{
	int len;//用来存放有效节点的个数
	int i;
	int val;//用来临时存放用户输入的节点的值

	//分配了一个不存放有效数据的头节点
	PNODE pHead=(PNODE)malloc(sizeof(NODE));
	if(NULL==pHead)
	{
		printf("分配失败，程序终止！\n");
		exit(-1);
	}
	PNODE pTail=pHead;
	pTail->pNext=NULL;
	printf("请输入您需要生成的链表节点的个数：len=");
	scanf("%d",&len);

	for (i=0;i<len;i++)
	{
		printf("请输入第%d个节点的值:",i+1);
		scanf("%d",&val);

		PNODE pNew=(PNODE)malloc(sizeof(NODE));
		if(NULL==pNew)
		{
			printf("分配失败，程序终止！\n");
			exit(-1);
		}
		pNew->data=val;//挂
		pTail->pNext=pNew;
		pNew->pNext=NULL;
		pTail=pNew;
	
	}
	return pHead;
}

void traverse_list(PNODE pHead)
{
	PNODE p=pHead->pNext;
	while(NULL!=p)
	{
		printf("%d ",p->data);	
		p=p->pNext;//不连续，不能用p++
	}
	printf("\n");
	return;
}

bool is_empty(PNODE pHead)
{
	if(pHead->pNext==NULL)
		return true;
	else
		return false;
}

int length_list(PNODE pHead)
{
	PNODE p=pHead->pNext;
	int len=0;
	while(NULL!=p)
	{
		len++;
		p=p->pNext;
	}
	return len;
}

在这里插入图片描述
在这里插入图片描述

26_通过链表排序算法的演示再次详细讨论到底什么是算法以及到底什么是泛型【重点】

算法：
狭义的算法是与数据的存储方式密切相关
广义的算法是与数据的存储方式无关
泛型：
利用某种技术达到的效果就是：不同的存储方式，执行的操作是一样的
排序：
在这里插入图片描述

void sort_list(PNODE pHead)
{
	int i,j,t;
	int len=length_list(pHead);
	PNODE p,q;
	for(i=0,p=pHead->pNext;i<len-1;++i,p=p->pNext)
	{
		for(j=i+1,q=p->pNext;j<len;++j,q=q->pNext)
		{
			if(p->data>q->data)//类似于数组中的：a[i]>a[j]
			{
				t=p->data;//类似于数组中的：	t=a[i];
				p->data=q->data;//类似于数组中的：	a[i]=a[j];
				q->data=t;//类似于数组中的：	a[j]=t;
			}
		}
	}

}

测试：

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

typedef struct Node
{
	int data;//数据域
	struct Node * pNext;//指针域
}NODE,*PNODE;//NODE等价于struct Node，PNODE等价于struct Node *
//函数声明
PNODE create_list(void);
void traverse_list(PNODE pHead);
bool is_empty(PNODE pHead);
int length_list(PNODE);
bool insert_list(PNODE,int,int);
bool delete_list(PNODE,int,int*);
void sort_list(PNODE);


int main(void)
{
	PNODE pHead=NULL;//等价于struct Node *pHead=NULL；
	pHead=create_list();//creat_list()功能：创建一个非循环单链表,并将该链表的头节点的地址付给pHead
	traverse_list(pHead);
	int len=length_list(pHead);
	printf("链表长度是%d\n",len);

	if(is_empty(pHead))
		printf("链表为空！\n");
	else 
		printf("链表不空！\n");
	sort_list(pHead);
	traverse_list(pHead);


	return 0;
}

PNODE create_list(void)
{
	int len;//用来存放有效节点的个数
	int i;
	int val;//用来临时存放用户输入的节点的值

	//分配了一个不存放有效数据的头节点
	PNODE pHead=(PNODE)malloc(sizeof(NODE));
	if(NULL==pHead)
	{
		printf("分配失败，程序终止！\n");
		exit(-1);
	}
	PNODE pTail=pHead;
	pTail->pNext=NULL;
	printf("请输入您需要生成的链表节点的个数：len=");
	scanf("%d",&len);

	for (i=0;i<len;i++)
	{
		printf("请输入第%d个节点的值:",i+1);
		scanf("%d",&val);

		PNODE pNew=(PNODE)malloc(sizeof(NODE));
		if(NULL==pNew)
		{
			printf("分配失败，程序终止！\n");
			exit(-1);
		}
		pNew->data=val;//挂
		pTail->pNext=pNew;
		pNew->pNext=NULL;
		pTail=pNew;
	
	}
	return pHead;
}

void traverse_list(PNODE pHead)
{
	PNODE p=pHead->pNext;
	while(NULL!=p)
	{
		printf("%d ",p->data);	
		p=p->pNext;//不连续，不能用p++
	}
	printf("\n");
	return;
}

bool is_empty(PNODE pHead)
{
	if(pHead->pNext==NULL)
		return true;
	else
		return false;
}

int length_list(PNODE pHead)
{
	PNODE p=pHead->pNext;
	int len=0;
	while(NULL!=p)
	{
		len++;
		p=p->pNext;
	}
	return len;
}

void sort_list(PNODE pHead)
{
	int i,j,t;
	int len=length_list(pHead);
	PNODE p,q;
	for(i=0,p=pHead->pNext;i<len-1;++i,p=p->pNext)
	{
		for(j=i+1,q=p->pNext;j<len;++j,q=q->pNext)
		{
			if(p->data>q->data)//类似于数组中的：a[i]>a[j]
			{
				t=p->data;//类似于数组中的：	t=a[i];
				p->data=q->data;//类似于数组中的：	a[i]=a[j];
				q->data=t;//类似于数组中的：	a[j]=t;
			}
		}
	}
}

在这里插入图片描述

27_如何学习算法自己的一些感想

28_链表插入和删除算法的演示

插入：

//在pHead所指向链表的第pos个节点的前面插入一个新的节点，新节点的值是val，并且pos的值是从1开始
bool insert_list(PNODE pHead,int pos,int val)
{
	int i=0;
	PNODE p=pHead;

	while(NULL!=p&&i<pos-1)
	{
		p=p->pNext;
		++i;
	}
	if(i>pos-1||NULL==p)  //这句话可以排除所有意外情况
		return false;
	PNODE pNew=(PNODE)malloc(sizeof(NODE));
	if(NULL==pNew)
	{
		printf("动态分配内存失败！\n");
		exit(-1);
	}
	pNew->data=val;

	PNODE q=p->pNext;   //定义一个临时节点
	p->pNext=pNew;
	pNew->pNext=q;
	return true;

}

删除：

bool delete_list(PNODE pHead,int pos,int* pVal)
{
	int i=0;
	PNODE p=pHead;

	while(NULL!=p->pNext&&i<pos-1)
	{
		p=p->pNext;
		++i;
	}
	if(i>pos-1||NULL==p->pNext)
		return false;
	PNODE q=p->pNext;
	*pVal=q->data;
	//删除p节点后面的节点
	p->pNext=p->pNext->pNext;
	free(q);
	q=NULL;
}

测试：

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

typedef struct Node
{
	int data;//数据域
	struct Node * pNext;//指针域
}NODE,*PNODE;//NODE等价于struct Node，PNODE等价于struct Node *
//函数声明
PNODE create_list(void);
void traverse_list(PNODE pHead);
bool is_empty(PNODE pHead);
int length_list(PNODE);
bool insert_list(PNODE,int,int);
bool delete_list(PNODE,int,int*);
void sort_list(PNODE);


int main(void)
{
	PNODE pHead=NULL;//等价于struct Node *pHead=NULL；
	int val;
	pHead=create_list();//creat_list()功能：创建一个非循环单链表,并将该链表的头节点的地址付给pHead
	traverse_list(pHead);
	int len=length_list(pHead);
	printf("链表长度是%d\n",len);

	if(is_empty(pHead))
		printf("链表为空！\n");
	else 
		printf("链表不空！\n");
	sort_list(pHead);
	traverse_list(pHead);
	insert_list(pHead,4,33);
	traverse_list(pHead);
	if (delete_list(pHead,4,&val))
	{
		printf("删除成功，您删除的元素是：%d\n",val);
	}
	else
	{
		printf("删除失败！您删除的元素不存在!\n");
	}
	traverse_list(pHead);

	return 0;
}

PNODE create_list(void)
{
	int len;//用来存放有效节点的个数
	int i;
	int val;//用来临时存放用户输入的节点的值

	//分配了一个不存放有效数据的头节点
	PNODE pHead=(PNODE)malloc(sizeof(NODE));
	if(NULL==pHead)
	{
		printf("分配失败，程序终止！\n");
		exit(-1);
	}
	PNODE pTail=pHead;
	pTail->pNext=NULL;
	printf("请输入您需要生成的链表节点的个数：len=");
	scanf("%d",&len);

	for (i=0;i<len;i++)
	{
		printf("请输入第%d个节点的值:",i+1);
		scanf("%d",&val);

		PNODE pNew=(PNODE)malloc(sizeof(NODE));
		if(NULL==pNew)
		{
			printf("分配失败，程序终止！\n");
			exit(-1);
		}
		pNew->data=val;//挂
		pTail->pNext=pNew;
		pNew->pNext=NULL;
		pTail=pNew;
	
	}
	return pHead;
}

void traverse_list(PNODE pHead)
{
	PNODE p=pHead->pNext;
	while(NULL!=p)
	{
		printf("%d ",p->data);	
		p=p->pNext;//不连续，不能用p++
	}
	printf("\n");
	return;
}

bool is_empty(PNODE pHead)
{
	if(pHead->pNext==NULL)
		return true;
	else
		return false;
}

int length_list(PNODE pHead)
{
	PNODE p=pHead->pNext;
	int len=0;
	while(NULL!=p)
	{
		len++;
		p=p->pNext;
	}
	return len;
}

void sort_list(PNODE pHead)
{
	int i,j,t;
	int len=length_list(pHead);
	PNODE p,q;
	for(i=0,p=pHead->pNext;i<len-1;++i,p=p->pNext)
	{
		for(j=i+1,q=p->pNext;j<len;++j,q=q->pNext)
		{
			if(p->data>q->data)//类似于数组中的：a[i]>a[j]
			{
				t=p->data;//类似于数组中的：	t=a[i];
				p->data=q->data;//类似于数组中的：	a[i]=a[j];
				q->data=t;//类似于数组中的：	a[j]=t;
			}
		}
	}

}

//在pHead所指向链表的第pos个节点的前面插入一个新的节点，新节点的值是val，并且pos的值是从1开始
bool insert_list(PNODE pHead,int pos,int val)
{
	int i=0;
	PNODE p=pHead;

	while(NULL!=p&&i<pos-1)
	{
		p=p->pNext;
		++i;
	}
	if(i>pos-1||NULL==p)  //这句话可以排除所有意外情况
		return false;
	PNODE pNew=(PNODE)malloc(sizeof(NODE));
	if(NULL==pNew)
	{
		printf("动态分配内存失败！\n");
		exit(-1);
	}
	pNew->data=val;

	PNODE q=p->pNext;   //定义一个临时节点
	p->pNext=pNew;
	pNew->pNext=q;
	return true;

}

bool delete_list(PNODE pHead,int pos,int* pVal)
{
	int i=0;
	PNODE p=pHead;

	while(NULL!=p->pNext&&i<pos-1)
	{
		p=p->pNext;
		++i;
	}
	if(i>pos-1||NULL==p->pNext)
		return false;
	PNODE q=p->pNext;
	*pVal=q->data;
	//删除p节点后面的节点
	p->pNext=p->pNext->pNext;
	free(q);
	q=NULL;

}

在这里插入图片描述

29_复习

数据结构
狭义：
数据结构是专门研究数据存储的问题
数据的存储包含两方面：个体的存储+个体关系的存储
广义：
数据结构既包括数据的存储也包括数据的操作
对存储数据的操作就是算法
算法
狭义：
算法是和数据的存储方式密切相关
广义：
算法和数据的存储方式无关
这就是泛型思想

数据的存储方式有几种：
1、线性
（1）连续存储【数组】
优点
存取速度很快
缺点
事先需要知道数组的长度
插入删除元素很慢
空间通常有限制
需要大块连续的内存块

（2）离散存储【链表】
优点
空间没有限制
插入删除元素很快
缺点
存取速度很慢
2、非线性
树
图

C语言数据结构之链表
2301_81988400的博客
04-21 4399
链表的概念及结构、链表的分类、无头单向非循环链表的实现、带头双向循环链表的实现、顺序表和链表的对比。
C语言数据结构-链表
2302_81072215的博客
11-26 1860
图中指针变量plist保存的是第一个结点的地址，我们称plist此时“指向”第一个结点，如果我们希望plist“指向”第二个结点时，只需要修改plist保存的内容为0x0012FFA0.在前面说的单链表中的“头结点”，该头结点是链表的首节点（第一个结点），实际这样的称呼是错误的，因为链表中存在一种链表叫做带头链表（不是指链表里第一个有效的结点），这里的头结点指的是，在这里直接使用plist来遍历结果也是一样的，重新创建个pcur指针，是为了避免由于指针指向的改变，导致无法重新找到链表的首结点。
C语言链表完整代码
08-23
学完C语言之后自己编写的源码且带有注释，代码条理清晰通俗易懂，希望能帮到正在学习C的小伙伴们。
C语言数据结构代码——链表
qq_41862220的博客
04-27 789
Head.C typedef struct _chain { int num; struct _chain *next; } Chain, *chain; chain CreateList(int size); void FreeChainList(chain L); void FreeAimNode(chain L, int location); void PrintChain(cha...
链表【C语言实现】
最新发布
2301_80426325的博客
06-28 1169
单链表、双向循环链表
C语言 数据结构 链表 基本操作代码
qq_48596586的博客
04-26 2394
#include <stdio.h> #include <stdlib.h> #define DataType int /* * LinkedList */ typedef struct node { DataType data; struct node* next; }LinkList; void initList(LinkList *list) { if (list != NULL) { list = (LinkList*) m
数据结构-链表（代码详解）
hcx009的博客
04-23 2440
数据结构与算法——线性表（链表篇）_线性链表-优快云博客，但是这篇博客不能细看，也不能深究，因为错误和纰漏太多了，包括但不限于变量名的错误，函数传参的误导性，以及部分知识点错的离谱，本文也只是跟着这篇博客整理的知识点的结构来自己写的代码，毕竟：Talk is cheap, show me the code.//1.//2.//这里的typedef是取别名的意思//把 struct LNode取个简单的名字为 LNode。
c语言数据结构链表程序,C语言 数据结构之链表实现代码
weixin_29133981的博客
05-17 253
前言最近在复习数据结构的相关知识，感觉在初学的时候还是有很多东西没有掌握，不过现在终于算是搞得比较有头绪了，所以就在写出来和大家一起分享！什么是链表简单的说，链表就是由多个结点离散分配，彼此通过指针相连，每个结点只有一个前驱结点和后继结点。首节点无前驱结点，为结点无后继结点的一种存储结构。链表的结构头结点：链表的第一个有效结点前面的结点，头结点并不存放有效数据，也就是数据域为空，加头结点的主要目的...
C语言 数据结构之链表实现代码
09-01
链表是一种重要的数据结构，它在计算机科学中广泛应用于各种算法和数据管理。与数组不同，链表的元素不是在连续的内存空间中存储，而是通过指针链接在一起。链表分为多种类型，如单链表、双向链表、循环链表等。本文...
C语言实现链表数据结构超详细教程（图解+代码逐行分析）
sanyueqi520的博客
04-17 1113
链表是数据结构中最基础也是最重要的线性结构之一。相较于数组，链表具有动态内存分配的优势，可以更灵活地进行插入和删除操作。本文将通过C语言完整实现链表结构，并特别针对初学者设计，包含详细注释和图示说明。c#define _CRT_SECURE_NO_WARNINGS 1 // 禁用VS安全警告#define DL 3 // 定义数字显示宽度#define STR(n) #n // 将数字转为字符串。
数据结构_C语言_链表多项式相加_教学示例_1741871959.zip
03-16
本次课程将着重介绍使用C语言实现链表数据结构来完成多项式相加的过程，这一过程是数据结构教学中的一个重要示例。 链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据部分和指向下一个节点的指针。...
链表c语言代码
08-30
数据结构c语言链表的代码分享 struct LinkNode { int data; struct LinkNode *next; }; typedef struct LinkNode *Lnode; struct LinkList { Lnode pHeader; //头节点 int m_Size; //长度 }; typedef struct LinkList *Llist; ....
C语言链表代码
01-06
关于c语言中链表的问题创建，排序，倒叙，创建有序，组合链表
c语言链表代码
03-23
用c语言实现的数据结构里的代码。单链表，有初始化，添加，删除，插入。
数据结构链表C语言实现
11-12
课程要求，线性表链式存储结构。有尾接法也有头接法。
数据结构-链表代码详解（C语言）
TangJin4444的博客
05-27 942
【代码】数据结构-链表代码详解（C语言）
数据结构—链表的基本操作（c语言代码）
軒轅劍的博客
06-06 7652
链表链表也是一种线性表，与顺序表不同之处在于不像顺序表占据一段连续的存储空间，而是将存储单元分散在内存的任意地址上。链表结构中，储存每个数据时候都会把记录写在链表的一个结点（node）中，每个结点之间由指针相连，形成如同链子的结构。结点（node）：可以是一个结构体类型元素，必须有一个专门来存放地址的域，用这个域来存放后继结点的地址，这样就连接起来链表组成：通常有表头（指针变量，存放第一个结点地址...
链表c代码
Tracy Mcgrady的专栏
06-18 2901
#include #include struct node { int data; struct node *next; }; int datas[] = {1, 2, 4, 8, 16, 32, 64, 128}; void list_head_init(struct node *head) { head->data = 0; head->next = NULL; } int
c语言链表代码大全,C语言链表完整实现(示例代码)
weixin_39690105的博客
05-18 424
#include #include #define ElementType inttypedef struct Node *List;typedef struct Node{ElementType Data;List Next;};int Length(List PtrL);List FindKth(int K,List PtrL);List Find(ElementType X,List Ptr...
C语言实现链表数据结构源代码解析
资源摘要信息:"链表数据结构C代码.zip文件包含了有关链表的基础程序代码，这些程序涉及单链表和双链表的基本操作。在数据结构领域，链表是一种常见的线性数据结构，由一系列节点组成，每个节点包含数据和指向下一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值