数据结构之链表（C语言）

最新推荐文章于 2024-06-06 09:00:00 发布
最新推荐文章于 2024-06-06 09:00:00 发布
阅读量690 收藏 6
点赞数 2
文章标签： 数据结构 链表 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sskdspdl/article/details/132638304
版权

链表的概念：

  链表（Linked List）是数据结构中常见的一种基础数据结构，它由一些列节点（Node）组成，每一个节点都包含两部分，一部分是存储数据的数据域（Data），另一部分是记录下一个节点位置的指针域（Next）。链表中的节点在内存中存储的位置是不连续的，而是通过指针来相互连接。

链表有单向链表和双向链表两种形式。接下来我将通过C语言来实现单链表和双链表的一些基本操作，代码统一使用全局变量的头指针的形式来实现。

单链表：

1、建立单链表：

单链表的建立通常使用头插法或者尾插法；

通用代码：

struct Node {   //结构体定义
	int data;
	struct Node* next;
};

int count = 0; //计算节点的数量
struct Node* head = NULL; //头指针

struct Node* new(int x)  
{
	struct Node* temp = (struct Node*)malloc(sizeof(struct Node)); //给新节点分配内存
    temp->data = x;  //赋值
    temp->next = NULL; 
	return temp;
}

头插法将新节点插入链表的开头；

代码实现：

void headList(int data)
{
	struct Node* A = new(data); //创建新节点
	A->next = head; //新节点的指针指向头指针指向的节点
	head = A; //头指针指向新节点
    count++;
}

尾插法将新节点插入链表的尾巴；

代码实现：

void lastList(int data)
{
	struct Node* k = head; //该变量用来替代头指针来进行移动
	struct Node* temp = new(data);
	if (k == NULL) //链表为空
	{
		temp->next = head;
		head = temp;
   
		return;
	}
	while (k->next != NULL) Move to the last node
		k = k->next;
	temp->next = k->next; 
	k->next = temp;
    count++;
}

2、单链表的按位插入

单链表的按位插入是指在指定位置插入一个节点。具体步骤如下：

  1. 定义要插入的节点，并赋值。
  2. 找到要插入位置前一个节点，并定义一个指向该节点的指针p。
  3. 将要插入节点的next指针指向p的next指针所指向的节点。
  4. 将p的next指针指向要插入的节点。

代码实现：

void insert(int x, int data) //x是插入位置 data是新节点的数据
{
	struct Node* sert = head; //因为head是全局变量
	struct Node* temp = new(data);
	if (x<1 || x>count) //插入位置非法
	{
		printf("error!");
		return;
	}
	for (int i = 1; i < x - 1; i++) //移动到插入的位置
		sert = sert->next;
	temp->next = sert->next;
	sert->next = temp;
}

3、单链表的按位查找和按值查找

步骤基本与按位插入一致；

代码实现：

//按位查找
void finder1(int x)
{
	struct Node* find = head; 
	if (head == NULL) //链表为空
	{
		printf("empty!\n");
		return;
	}
	if (x<1 || x > count) //查找位置非法
	{
		printf("error!\n");
		return;
	}
	for (int i = 1; i < x; i++)
	{
		find = find->next;
	}
	printf("number is %d \n", find->data); //打印
}

//按值查找
void finder2(int x)
{
	struct Node* find = head;
	while (find != NULL)
	{
		if (find->data == x)
		{
			printf("finding on");
			return;
		}
		find = find->next;
	}
	printf("false");
}

4、单链表的节点删除

代码实现：

void delete(int x)
{
	if (x<1 || x>count)
	{
		printf("error!\n");
		return;
	}
	struct Node* deleter = head;
	for (int i = 1; i < x - 1; i++) //移动到删除节点的前一个节点
	{
		deleter = deleter->next;
	}
	struct Node* A = deleter->next; //用于释放删除节点空间
	deleter->next = deleter->next->next;
	free(A);
}

完整代码实现：
 

struct Node {
	int data;
	struct Node* next;
};

struct Node* head = NULL; //头指针

int count = 0; //计算节点的数量
struct Node* new(int x)
{
	struct Node* temp = (struct Node*)malloc(sizeof(struct Node));
    temp->data = x; 
    temp->next = NULL;
	return temp;
}
头插法
void headList(int data)
{
	struct Node* A = new(data); //创建新节点
	A->next = head;
	head = A;
	count++;

}
尾插法
void lastList(int data)
{
	struct Node* k = head; //该变量用来替代头指针来进行移动
	struct Node* temp = new(data);
	if (k == NULL) //链表为空
	{
		temp->next = head;
		head = temp;
		count++;
		return;
	}
	while (k->next != NULL) //移动到最后一个节点
		k = k->next;
	temp->next = k->next; 
	k->next = temp;
	count++;
}
//按位插入
void insert(int x, int data)
{
	struct Node* sert = head; //因为head是全局变量
	struct Node* temp = new(data);
	if (x<1 || x>count) //查找位置非法
	{
		printf("error!");
		return;
	}
	for (int i = 1; i < x - 1; i++) //移动到插入的位置
		sert = sert->next;
	temp->next = sert->next;
	sert->next = temp;
}
//按位查找
void finder1(int x)
{
	struct Node* find = head;
	if (head == NULL)
	{
		printf("empty!\n");
		return;
	}
	if (x<1 || x > count)
	{
		printf("error!\n");
		return;
	}
	for (int i = 1; i < x; i++)
	{
		find = find->next;
	}
	printf("number is %d \n", find->data);
}
//按值查找
void finder2(int x)
{
	struct Node* find = head;
	while (find != NULL)
	{
		if (find->data == x)
		{
			printf("finding on");
			return;
		}
		find = find->next;
	}
	printf("false");
}
//删除
void delete(int x)
{
	if (x<1 || x>count)
	{
		printf("error!\n");
		return;
	}
	struct Node* deleter = head;
	for (int i = 1; i < x - 1; i++)
	{
		deleter = deleter->next;
	}
	struct Node* A = deleter->next;
	deleter->next = deleter->next->next;
	free(A);
}
打印
void Print()
{
	struct Node* h = head;
	while (h != NULL)
	{
		printf("%d ", h->data);
		h = h->next;
	}
	printf("\n");
}
int main()
{
	lastList(3);
	lastList(1);
	lastList(8);
	lastList(2);
	lastList(31);
	lastList(32);
	Print();
	delete(4);
	Print();
	insert(4, 9);
	Print();
	finder1(5);
    finder2(2);
	return 0;
}

双链表：

1、建立双链表：

通用代码：

struct Node {
	int data;
	struct Node* per;
	struct Node* next;
};

int count = 0;

struct Node* head = NULL;

struct Node* new(int n) //新节点
{
    struct Node* temp = (struct Node*)malloc(sizeof(struct Node));
    temp->data = n;
    temp->next = NULL;
    temp->per = NULL;
	return temp;
}

头插法：

代码实现：

void headList(int x)
{
	struct Node* temp = new(x);
	if (head == NULL) 
	{
		temp->next = head;
		head = temp;
		temp->per = NULL;
		count++;
		return;
	}
	temp->next = head; //新节点指向head指向的节点
	head->per = temp; //head指向的节点指向新节点
	head = temp;  //改变head指向 
    temp->per = NULL;
	count++;
}

尾插法：

代码实现：

void lastList(int x)
{
	struct Node* header = head;
	struct Node* temp = new(x);
	if (head == NULL)
	{
		temp->next = head;
		head = temp;
		temp->per = NULL;
		count++;
		return;
	}
	while (header->next != NULL) //移动到最后节点
	{
		header = header->next;
	}
	temp->next = header->next;
	header->next = temp;
	temp->per = header;
	count++;
}

2、双链表的按位插入

代码实现：

void Insert(int x,int data)
{
	if (x<1 || x>count) //判断插入位置是否非法
	{
		printf("error!\n");
		return;
	}
	struct Node* header = head;
	struct Node* temp = new(data);
	for (int i = 1; i < x-1; i++)//移动到插入位置前一个位置
	{
		header = header->next;
	}
	temp->next = header->next;
	temp->per = header;
	header->next->per = temp; //插入位置的前节点指向新节点
	header->next = temp; 
	count++;
}

3、双链表的按位删除

双链表的删除操作需要注意边界问题，若删除为首节点时，应及时更新头指针的指向，若删除尾节点时，应做特殊处理。

代码实现：

void delete(int x)
{
	struct Node* header = head;
	if (x<1 || x>count)
	{
		printf("error!\n");
		return;
	}
	if (x == 1) //删除首节点
	{
		struct Node* B = header;
		header = B->next;
		head = header; //注意要更新头指针
		header->per = NULL;
		printf("delete a number : %d\n", B->data);
		free(B);
		count--;
		return;
	}
	for (int i = 1; i < x-1 ; i++) //前一个节点
	{
		header = header->next;
	}
	struct Node* A = header->next;
	if (A->next == NULL) //若删除节点为最后的节点
	{
		printf("delete a number : %d\n", A->data);
		header->next = A->next;  //直接更新前节点的next指针就行
		free(A);
		count--;
		return;
	}
	header->next = A->next;
	A->next->per = header;
	printf("delete a number : %d\n", A->data);
	free(A);
	count--;
}

4、双链表的前后遍历

代码实现：

//链表的遍历
void Print()
{
	struct Node* header = head;
	while (header != NULL) //从前遍历
	{
		if (header->next == NULL) //方便从后面遍历
		{
			printf("%d", header->data);
			break;
		}
		printf("%d ", header->data);
		header = header->next;
	}
	printf("\n");
	while (header != NULL)
	{
		if (header->next == NULL)
			break;
		header = header->next;
	}
	while (header != NULL)
	{
		printf("%d ", header->data);
		header = header->per;
	}
	printf("\n");
}

完整代码：
 

struct Node {
	int data;
	struct Node* per;
	struct Node* next;
};

int count = 0;
struct Node* new(int n) //新节点
{
    struct Node* temp = (struct Node*)malloc(sizeof(struct Node));
    temp->data = n;
    temp->next = NULL;
    temp->per = NULL;
	return temp;
}

struct Node* head = NULL;
//头插法
void headList(int x)
{
	struct Node* temp = new(x);
	if (head == NULL) 
	{
		temp->next = head;
		head = temp;
		temp->per = NULL;
		count++;
		return;
	}
	temp->next = head;
	head->per = temp;
	head = temp;
	temp->per = NULL;
	count++;
}
//
//尾插法
void lastList(int x)
{
	struct Node* header = head;
	struct Node* temp = new(x);
	if (head == NULL)
	{
		temp->next = head;
		head = temp;
		temp->per = NULL;
		count++;
		return;
	}
	while (header->next != NULL) //移动到最后节点
	{
		header = header->next;
	}
	temp->next = header->next;
	header->next = temp;
	temp->per = header;
	count++;
}
//按位插入
void Insert(int x,int data)
{
	if (x<1 || x>count)
	{
		printf("error!\n");
		return;
	}
	struct Node* header = head;
	struct Node* temp = new(data);
	for (int i = 1; i < x-1; i++)//移动到插入位置前一个位置
	{
		header = header->next;
	}
	temp->next = header->next;
	temp->per = header;
	header->next->per = temp; //插入位置的前节点指向新节点
	header->next = temp; 
	count++;
}
//删除
void delete(int x)
{
	struct Node* header = head;
	if (x<1 || x>count)
	{
		printf("error!\n");
		return;
	}
	if (x == 1) //删除首节点
	{
		struct Node* B = header;
		header = B->next;
		head = header; //注意要更新头指针
		header->per = NULL;
		printf("delete a number : %d\n", B->data);
		free(B);
		count--;
		return;
	}
	for (int i = 1; i < x-1 ; i++) //前一个节点
	{
		header = header->next;
	}
	struct Node* A = header->next;
	if (A->next == NULL) //若删除节点为最后的节点
	{
		printf("delete a number : %d\n", A->data);
		header->next = A->next;
		free(A);
		count--;
		return;
	}
	header->next = A->next;
	A->next->per = header;
	printf("delete a number : %d\n", A->data);
	free(A);
	count--;
}
//链表的遍历
void Print()
{
	struct Node* header = head;
	while (header != NULL) //从前遍历
	{
		if (header->next == NULL) //方便从后面遍历
		{
			printf("%d", header->data);
			break;
		}
		printf("%d ", header->data);
		header = header->next;
	}
	printf("\n");
	while (header != NULL)
	{
		if (header->next == NULL)
			break;
		header = header->next;
	}
	while (header != NULL)
	{
		printf("%d ", header->data);
		header = header->per;
	}
	printf("\n");
}
int main()
{
	lastList(3);
	lastList(1);
	lastList(8);
	lastList(2);
	lastList(31);
	lastList(32);
	Print();
	Insert(3, 5);
	Print();
	delete(1);
	Print();
	return 0;
}

其他的链表操作基本上都是大同小异，例如双链表查找最小值、按值查找、暗值删除等一些扩展的操作，可根据基础代码进行编写，加深对链表操作的理解和熟练度。

红鼻子怡宝
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
数据结构---单向链表，双向链表，单向环形链表
root1994的博客
07-09 5117
链表介绍 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域:指向下一个节点. 如图:发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 修改节点功能 思路(1) 先找到该节点，通过遍历，(2) temp.name = newHeroNode.name ; temp.nickname= newHeroNode.n...
数据结构—链表（c语言）
three_points的博客
05-17 514
链表的基本操作 链是一种非常重要的数据结构，我们可以对链表进行增删改查等基本操作 #include<stdio.h> #include<stdlib.h> struct node { int num,score; struct node * next; }; void find(struct node * head)/*查找节点*/ struct node *p; int x; printf("输入要查找的学号:\n"); scanf("%d",&x); p=h
【C语言】深入理解C语言链表
Goforyouqp的博客
07-18 1万+
链表是一种常见的数据结构，广泛应用于计算机科学中。C语言提供了丰富的指针操作，使得链表的实现相对简便。本博客将介绍链表的基本概念，以及使用C语言实现链表的代码示例。
【数据结构】链表
knous
03-13 6万+
链表
链表详解（附有C语言详细代码）
最新发布
Weirdo的博客
06-06 1889
在C语言中，可以使用结构体来定义链表节点。每个节点包含一个数据域（data）和一个指针域（next），其中指针域指向下一个节点。int data;// 数据域// 指针域} Node;链表作为一种重要的数据结构，具有动态分配、插入和删除操作方便等特点。通过定义节点结构、链表初始化、插入节点、删除节点和遍历链表等基本操作，可以实现链表的基本功能。此外，链表还有查找节点、反转链表、链表排序等扩展操作。链表在实际应用中具有广泛的应用场景，如文件存储、网络路由、哈希表冲突解决和LRU缓存淘汰策略等。
链表（详解）
m0_69323023的博客
08-30 7917
1、链表是物理存储单元上非连续的、非顺序的存储结构，数据元素的逻辑顺序是通过链表的指针地址实现，有一系列结点（地址）组成，结点可动态的生成。2、结点包括两个部分：（1）存储数据元素的数据域（内存空间），（2）存储指向下一个结点地址的指针域。3、相对于线性表顺序结构，操作复杂。
C语言数据结构——链表
zcxmjw的博客
12-22 1万+
大家好，本篇文章主要带领大家了解一下什么是链表，链表的两个主要结构，以及链表和顺序表的差别。
C语言—链表
weixin_73588765的博客
01-01 1万+
【C语言】—链表 创建,遍历,增删改查 链表是一种数据结构，是一种数据存放的思想；
数据结构-链栈(C语言)
Yeziquanquan的专栏
09-18 1092
带头结点链栈的实现
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
数据结构-链表的C语言使用
03-25
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。在C语言中，链表不像是数组那样在内存中连续存储元素，而是通过一系列分散的内存块（称为节点）来表示数据。每个...
数据结构C语言链表的实现
04-18
数据结构C语言链表的实现
C语言数据结构链表源码
08-13
C语言常用数据结构中链表使用源码，有助于C语言数据结构新手或小白学习。
C语言数据结构旋转链表的实现
12-31
C语言数据结构旋转链表的实现 实例： 给出链表1->2->3->4->5->null和k=2 返回4->5->1->2->3->null 分析： 感觉很直观，直接把分割点找出来就行，记得k可能大于len,要取模 代码： /** * Definition for singly-...
[数据结构]——链表详解
m0_62023005的博客
09-19 4029
数据结构---链表详解
链表基础知识详解（非常详细简单易懂）
热门推荐
qq_61672347的博客
07-10 17万+
数据结构链表详解，创建，遍历，释放，节点的查找，节点的删除，插入节点，链表排序等操作，非常详细
C语言之链表详解
Wang_XB_3434的博客
04-10 6356
链表是一种基本的数据结构，它由一系列节点组成，每个节点包含一个值和指向下一个节点的指针。链表的特点是可以动态添加和删除节点，而不需要预先知道数据的数量。与数组不同，链表中的节点不一定是连续的存储空间，因此可以有效地利用内存空间。int val;
链表（C语言版）超详细讲解
h220321204的博客
08-15 1万+
而如果使用头插法，则需要遍历到链表的第一个节点，时间复杂度为O(n)，而且尾插法是由数据插入的顺序依次存储的，查找起来会更加方便。1、首先我们定义两个指针（x1,p）,x1作为头指针指向头结点（尾插法时不要移动头指针，我们只需移动p即可），p始终指向尾结点（这里我们初始化指向头结点），再申请一块结点并用x指向它。这样我们基础工作完成。
链表（超详细--包教包会）
Lushengshi的博客
02-20 6077
C\C++ 链表 包教包会
数据结构奇偶链表c语言
11-16
以下是一个C语言实现的奇偶链表的例子： ```c struct ListNode* oddEvenList(struct ListNode* head) { if (head == NULL) { return head; } struct ListNode* odd = head; // 奇数第一个结点 struct ListNode...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值