链表的使用

已于 2023-02-23 11:52:24 修改
阅读量797 收藏 15
点赞数 1
文章标签： 链表 数据结构 算法
于 2023-02-05 15:26:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/clmm_/article/details/128807022
版权

目录

目录

1.链表的基本概念

2.创建单链表

3.插入结点（头部插入法）

4.遍历链表

5.链表结点的删除

6.链表的释放

7.翻转链表

8.双向链表

一，链表的基本概念

什么是链表？

其实就是很多个相同类型结构体成线性排列，“串”在一起，形成一条链，叫做链表。

怎么做到结构体和结构体之间能“串”在一起？

链表中的每个结构体都相当于一个结点，我们创建的结构体，分为两块区域，

一块叫数据域，用于存储我们想存放的信息，

另一块叫指针域，用于存放下一个结点的地址（这样才能访问下一个结点，乃至整条链表）

比如我现在创建了一个结构体，如下

typedef struct Node
{
	int data;//数据域
	struct Node* next;//指针域
}Node;

我们要将若干个相同的结构体串联成如下效果 

静态链表的使用，利于理解上图

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

void test()
{
	struct Node node1 = { 1,NULL };
	struct Node node2 = { 2,NULL };
	struct Node node3 = { 3,NULL };
	struct Node node4 = { 4,NULL };
	struct Node node5 = { 5,NULL };

	node1.next = &node2;
	node2.next = &node3;
	node3.next = &node4;
	node4.next = &node5;

	//遍历列表
	struct Node* pCurrent = &node1;
	while (pCurrent)
	{
		printf("%d\n", pCurrent->data);
		pCurrent = pCurrent->next;
	}


}



int main()
{
	test();
	return 0;
}

二，创建单链表

创建一个单链表，相当于创造一个作为头的结点，头结点后的链表身，属于链表插入的内容

Node* creathead()
{
	Node* headnode = (Node*)malloc(sizeof(Node));//创建一个指针，要么初始化，要么制空
	if (headnode == NULL)
	{
		printf("创建头节点失败\n");
		exit(0);
	}
	headnode->next = NULL;
	return headnode;
}

这样我们就创建好了头结点，然后把头结点的地址返回主函数，有了头结点的地址就可以访问整个链表

三，插入结点（头部插入法）

 （借用一下其他博主的图）

Node* creatnode(int input)
{
	Node* node = (Node*)malloc(sizeof(Node));
	if (node == NULL)
	{
		printf("添加数据失败\n");
		exit(0);
	}
	node->data = input;
	node->next = NULL;
	return node;
}

四，遍历链表

void PrintNode(Node* headnode)
{
	Node* pMove = headnode->next;//定义一个辅助指针，用于遍历
	while (pMove)
	{
		printf("%d\n", pMove->data);
		pMove = pMove->next;
	}

}

五，链表结点的删除

void DelectNode(Node* headnode)
{
	int input = 0;
	scanf("%d", &input);
	Node* pMove = headnode;//定义一个辅助指针，用于遍历
	while (pMove->next != NULL && pMove->next->data != input)//这里不能调换顺序！
	{                                                        //要先判断pMove->next是否为NULL，
		pMove = pMove->next;                                 //再判断pMove->next->data，
	}                                                        //否则就读取了空指针的data，会报错！
                                                              
	if (pMove->next == NULL)
	{
		printf("该结点不存在\n");
		exit(0);
	}

	Node* d = pMove->next;
	pMove->next = pMove->next->next;
	free(d);
	printf("该结点已删除\n");
}

六，释放链表

void FreeNode(Node* headnode)
{
	Node* pMove = headnode;
	Node* pfree = pMove;
	while (pMove != NULL)
	{
		pMove = pMove->next;
		free(pfree);
		pfree = pMove;

	}

	printf("链表已释放成功\n");
}

最后是全部源代码

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

Node* creathead()
{
	Node* headnode = (Node*)malloc(sizeof(Node));//创建一个指针，要么初始化，要么制空
	if (headnode == NULL)
	{
		printf("创建头节点失败\n");
		exit(0);
	}
	headnode->next = NULL;
	return headnode;
}

Node* creatnode(int input)
{
	Node* node = (Node*)malloc(sizeof(Node));
	if (node == NULL)
	{
		printf("添加数据失败\n");
		exit(0);
	}
	node->data = input;
	node->next = NULL;
	return node;
}

void PrintNode(Node* headnode)
{
	Node* pMove = headnode->next;//定义一个辅助指针，用于遍历
	while (pMove)
	{
		printf("%d\n", pMove->data);
		pMove = pMove->next;
	}

}



void DelectNode(Node* headnode)
{
	int input = 0;
	scanf("%d", &input);
	Node* pMove = headnode;//定义一个辅助指针，用于遍历
	while (pMove->next != NULL && pMove->next->data != input)//这里不能调换顺序！
	{                                                        //要先判断pMove->next是否为NULL，
		pMove = pMove->next;                                 //再判断pMove->next->data，
	}                                                        //否则就读取了空指针的data，会报错！
                                                              
	if (pMove->next == NULL)
	{
		printf("该结点不存在\n");
		exit(0);
	}

	Node* d = pMove->next;
	pMove->next = pMove->next->next;
	free(d);
	printf("该结点已删除\n");
}

void FreeNode(Node* headnode)
{
	Node* pMove = headnode;
	Node* pfree = pMove;
	while (pMove != NULL)
	{
		pMove = pMove->next;
		free(pfree);
		pfree = pMove;

	}

	printf("链表已释放成功\n");
}
int main()
{
	int input = 0;
	Node* headnode = creathead();//创建头结点
	Node* p = headnode;//辅助指针
	
	for (int i = 0; i < 5; i++)//头部插入法
	{
		scanf("%d", &input);
		Node* node = creatnode(input);//创建结点
		node->next = p->next;
		p->next = node;
	}

	
	//endinsert(headnode);
	DelectNode(headnode);
	PrintNode(headnode);//遍历链表
	FreeNode(headnode);
	return 0;
}

7.翻转链表（无头）

Node* ReverseList(Node* headnode)//翻转无头链表
{
	Node* n1;//还未考虑链表小于3的情况
	Node* n2;
	Node* n3;
	n1 = NULL;
	n2 = headnode;
	n3 = headnode->next;
	while (n2 != NULL)//迭代
	{
		n2->next = n1;
		n1 = n2;
		n2 = n3;
		if (n3)
		{
			n3 = n3->next;
		}
		
	}
	printf("链表翻转成功\n");
	return n1;
}

8.双向链表

typedef struct Node
{
	int val;
	Node* pre;
	Node* next;
}Node;
Node* CreatList()
{
	Node* head = (Node*)malloc(sizeof(Node));
	head->val = NULL;
	head->pre = head;
	head->next = head;
	return head;
}
void ListPushBack(Node* head,int val)//尾插法
{
	Node* node = (Node*)malloc(sizeof(Node));
	Node* tail = head->pre;
	
	node->val = val;
	node->pre = tail;
	node->next = head;

	tail->next = node;
	head->pre = node;
	

}
void DelectNode(Node* head,int val)//尾删法
{
	Node* cur = head->next;
	while (cur != head)
	{
		if (cur->val == val)//指定数据的删除（还不够完善）
		{
			cur->pre->next = cur->next;
			cur->next->pre = cur->pre;
			cur->next = NULL;
			cur->pre = NULL;
			free(cur);
			printf("删除成功");
			break;
		}
		cur = cur->next;
	}
	if (cur == head)
	{
		printf("该结点不存在\n");
	}
	
}
void SearchNode(Node* head, int val)
{
	Node* cur = head->next;
	while (cur != head)
	{
		if (cur->val == val)//指定数据的删除（还不够完善）
		{
			printf("找到了，该结点存在\n");
			break;
		}
		cur = cur->next;
	}
	
	if (cur == head)
	{
		printf("该结点不存在\n");
	}
}

void ModifyNode(Node* head, int val)
{
	int input = 0;
	Node* cur = head->next;
	while (cur != head)
	{
		if (cur->val == val)//指定数据的删除（还不够完善）
		{
			printf("您要将数据%d修改为:\n",val);
			scanf("%d", &input);
			cur->val = input;
			printf("修改成功\n");
			break;
		}
		cur = cur->next;
	}

	if (cur == head)
	{
		printf("该结点不存在\n");
	}
}
void ListPrint(Node* head)
{
	Node* cur = head->next;
	while (cur->next != head)
	{
		printf("%d<->", cur->val);
		cur = cur->next;
	}
	printf("%d\n", cur->val);
	
}
int main()
{
	Node* head = CreatList();
	int i = 0;
	int val = 0;
	printf("请输入您要添加的数据:\n");
	for (i = 0; i < 5; i++)
	{
		scanf("%d", &val);
		ListPushBack(head, val);
		val = 0;
	}
	ListPrint(head);
	printf("请选择您要修改的数据:\n");
	scanf("%d", &val);
	ModifyNode(head, val);

	ListPrint(head);
	printf("请选择您要删除的数据:\n");
	scanf("%d", &val);
	DelectNode(head, val);

	ListPrint(head);
	printf("请选择您要查找的数据\n");
	scanf("%d", &val);
	SearchNode(head, val);
	return 0;
}

clmm_
关注
链表的常见用法
qq_30534935的博客
02-06 1599
转载： https://blog.csdn.net/zjwsa/article/details/77892208 https://segmentfault.com/a/1190000017790779 一、定义 链表的头文件： #include&amp;lt; stdlib&amp;gt; 链表的建立： struct node { int data; struct node *next...
单向链表常见操作
m0_72049276的博客
11-18 41
【代码】单向链表常见操作。
数据结构——链表
最新发布
2301_76227083的博客
09-11 1647
学习了顺序表就知道，顺序表在大量的头插或者中间插入的时候效率是很低的，需要频繁挪动数据，那么有没有一种数据结构在处理大量头插和中间插入的时候效率非常高呢？是有的，今天我们就来学习一下链表。
链表的基本使用
马赛克的博客
11-18 146
linkList.h #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<string.h> #include<stdlib.h> typedef struct LinkNode { int num; struct LinkNode * next; }LinkNode; //初始化链表,...
双向链表使用说明.txt
03-11
双向链表使用说明.txt
C语言 链表使用示例
06-15
本教程将通过两个经典示例深入讲解如何在C语言中使用链表。 首先，我们来看第一个示例——"Demo1.c"。在这个示例中，我们将创建一个表示学生成绩的链表，每个节点包含学生的ID和分数。为了实现这个链表，我们需要...
zf框架的db类select查询器join链表使用示例(zend框架)
10-26
主要介绍了zf框架的Db类select查询器join链表使用示例,需要的朋友可以参考下
c++链表使用教程
12-17
总结来说，这个C++链表教程涵盖了链表的基本概念、数据结构定义、操作符重载以及常见的链表操作函数实现，这些都是理解和使用链表的关键知识。通过这些内容，开发者可以有效地在C++中构建和管理链表数据结构，进行...
linux内核链表提取与使用
12-21
将linux内核源码中list.h拿出来, 增删与遍历部分写了详细注释, 关于链表合并, 没用过所以没写. 源码版本是2.6.32, 不过链表的源码改动应该不是很大. 我的邮箱2253238252@qq.com, 代码有什么不对的欢迎发邮件给我
链表使用
Sympathizer的博客
05-15 488
链表从堆中分配空间, 每个节点没有相对固定的位置关系。即写入内存的物理地址不是连续的（比如某个节点在地址A其后的节点不一定是A+1,而在内存的其他空闲区域，呈现一种随机的状态。） 链表定义：//定义链表中的节点 typedef struct node{ int data; //链表中的数据 struct node * p_next;//指向下一节点的指...
链表的用法
布呗之路
06-29 1354
久违的链表 mua mua mua ！！！#include&lt;bits/stdc++.h&gt; using namespace std; struct node{ int data; // 单链表的数据域 struct node *Next; // 单链表的指针域 }; /** 建立1：头插，逆序 */ node *creat1(int n){ node *he...
详细讲解链表的使用方法
galaxyrt的博客
06-04 3231
链表的使用 链表是常见的数据结构，由若干节点组成，这些节点可以在运行时动态生成 头指针：存放一个地址，该地址指向第一个节点， 结点：由需要处理的实际数据和指向下一个节点的指针组成 创建链表： 定义三个指针： head---表头指针，指向第一个节点 newnode---指向当前动态创建的节点 tail---表尾指针，指向当前链表的最后一个节点 创建步骤： 1、置空表： head=NULL; 2、动态创建新节点，让newnode指向该节点，并向其数据域输入数据： newnode=ne...
链表的基本用法
白日梦~
04-01 554
普通链表 struct STR{ int a; char c; struct STR *next; }; struct STR *creat(){ struct STR* head = NULL, * p1, * p2, * rear = NULL; int n = 0; p1 = p2 = (struct STR*)malloc(sizeof(struct STR));/*完全...
链表的基本操作
热门推荐
conanswp的专栏
04-09 9万+
链表的基本操作：内容包括链表的创建，增加、删除节点，链表的逆序、排序和销毁等。
链表的简单使用
m0_56690636的博客
07-15 132
简单粗暴，稍微记录一下，就上代码了 链表每一个节点包含数值域和下一个节点的地址；因此这就是其两个成员属性，将一个一个节点串起来，便形成了链表，这里是没有固定头的单链表。 package demo; /** * 每一个节点都是对象，都包含两个属性：数据和下一个节点的位置 */ public class Node { public int data; public Node next; public Node (int data){ this.data=data;
单链表和双向链表使用场景
09-03
单链表和双向链表是常见的数据结构，它们分别适用于不同的场景。 单链表是由一系列节点组成的数据结构，每个节点包含一个数据元素和一个指向下...在选择使用链表时，需要根据实际场景的需求综合考虑链表的特性和性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值