数据结构(链表篇)入门

已于 2024-06-22 18:56:52 修改
阅读量156 收藏 5
点赞数 9
分类专栏： 数据结构 文章标签： 数据结构 链表
于 2024-06-22 18:22:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66123058/article/details/139885862
版权

双向链表的设计与实现:

相比于单向链表，双向链表在指针域多出一个用于存储上一个结点的前驱指针这样的好处使得在结点插入或者删除时，我们就无需去查找/获取待操作结点的上一个结点了，因为在单向链表中结点插入或者删除，受形响的结点往往是上一 个结点。

插入删除不需要移动元素外，可以原地插入删除

可以双向遍历

1.双向链表的组成：
   1.1 头指针（指向头结点的指针变量）
   1.2节点/结点//双向链表
      1) 数据域
      2) 指针域

结构体:

//双向链表
typedef int data_t;
typedef struct linklist
{
	data_t data;
	struct linklist* prev;
	struct linklist* next;
	
}linklist_t;

创建链表:创建一个节点，返回节点地址

//创建节点  输出型参数返回地址(指针)
int list_create(linklist_t** head,data_t data)  //一级指针的时候此时head还是值传递 所以需要用二级指针对head指针的地址进行传递
{
	linklist_t *p = (linklist_t*)malloc(sizeof(linklist_t)); //申请一个节点空间
	if (p == NULL)
		return -1;

	p->data = data;
	p ->next = NULL;
	p->prev = NULL;

	*head = p;  //通过对头指针解引用
	return p;
}

 增加数据:

    1.头插法

    2.中间插法

    3.尾插法

1.头插法 

//在头结点插入元素(头插法)
int list_addhead(linklist_t** head, data_t data)
{
	linklist_t* p = (linklist_t*)malloc(sizeof(linklist_t));
	
	if (p == NULL)
		return -1;
	
	p->data = data;
	p->next = p ->prev = NULL;  //将要插入数据节点的后驱指向头结点的地址

	p->next = *head;  //通过对头指针解引用
	if (*head)
		(*head)->prev = p; //->的优先级大于*
	*head = p;

	return 0;
}

2.中间插法:需要考虑:1.是否是空链表 2.插入的位置是否是头节点 3.插入的位置是否是尾节点 4.中间插入数据 5.若要插入的数据未找到插入位置，则插入到链表的后面

 

//中间插法
int list_insert(linklist_t** head, data_t newdata,data_t olddata)
{
	linklist_t* pnew = (linklist_t*)malloc(sizeof(linklist_t));
	if (pnew == NULL)
		return -1;
	pnew->data = newdata;
	pnew->next = pnew->prev = NULL;

	linklist_t* p = *head,*q=NULL;
	if (p == NULL)             //链表为空,用新数据创建链表
	{
		*head = pnew;
		return 0;
	}
	if (memcmp(&p->data, &olddata, sizeof(data_t)) == 0) //插入的位置为头节点位置
	{
		pnew->next = p;
		p->prev = pnew;
		*head = pnew;
		return 0;
	}
	while (p)
	{
		if (memcmp(&p->data, &olddata, sizeof(data_t)) == 0) //插入到链表中的某节点位置
		{
			pnew->next = p;
			pnew->prev = p->prev;
			p->prev->next = pnew;
			p->prev = pnew;
			return 0;
		}
		q = p;  //使用快慢指针
		p = p->next;
	}
	//未找到插入位置,将新节点尾插到链表中
	q->next = pnew;
	pnew->prev = q;
	
	return 0;
}

3.尾插法

//在链表尾部插入数据(尾插法)
int list_addtail(linklist_t** head, data_t data)
{
	linklist_t* pnew = (linklist_t*)malloc(sizeof(linklist_t));
	
	if (pnew == NULL )
		return -1;
	pnew->data = data;
	pnew->next = pnew->prev = NULL;

	
	linklist_t* p = *head,*q=NULL; //利用快慢指针  要对head解引用
	if (p == NULL)
	{
		*head = pnew; //p为空，则head链表是空链表，所以将要插入的节点就为头节点
		return 0;
	}
	//遍历链表
	while (p->next)
	{
		p = p->next;
	}
	p->next = pnew;
	pnew->prev = p;
	return 0;
}

删除数据:需要考虑1.是否是空链表 2.该数据是否在链表中 3.删除的数据若为头节点则需考虑头节点是否是唯一的节点 ①是:p->next=NULL ②不是:p->next=p->prev=NULL; head=p->next; 4.如果删除的不是头节点则遍历链表找到要删除的数据，还要考虑是否删除的是尾节点p-next是否为NULL，①是:p->next->prev=NULL;②不是:p->next->prev=p->prev;

 

//删除节点
int list_delete(linklist_t** head, data_t data)
{
	linklist_t* p = *head;
	if (p == NULL)
		return -1;
	if (memcmp(&p->data, &data, sizeof(data_t)) == 0) //删除的是头节点
	{
		if (p->next == NULL) //头节点是唯一的节点
		{
			*head = NULL;
			
		}
		else //头节点不是唯一的节点
		{
			p->next->prev = NULL;
			*head = p->next;
		}
		free(p);
		return 0;
	}
	while (p)  //进入循环后表示删除的不是头节点
	{
		if (memcmp(&p->data, &data, sizeof(data_t)) == 0) //数据找到
		{
				p->prev->next = p->next;
			if(p->next) //删除的不是尾节点
				p->next->prev = p->prev;
			else //删除的是尾节点
			{
				p->prev->next = NULL;
			}
			free(p);//删除
			return 0;
		}
		p = p->next;
	}
	return -1;
}

 修改数据(与单向链表一样)

//修改数据
int list_updata(linklist_t** head, data_t olddata,data_t newdata)
{
	linklist_t* p = *head;
	if (p == NULL)
		return -1;
	while (p)
	{
		if (memcmp(&p->data, &olddata, sizeof(data_t)) == 0)
		{
			p->data = newdata;
			return 0;
		}
		p = p->next;
	}
	return -1;
}

查找数据(与单向链表一样)

//查找数据
linklist_t* list_find(linklist_t* head, data_t data)
{
	linklist_t* p = head;
	if (p == NULL)
		return -1;
	while (p)
	{
		if (memcmp(&p->data, &data, sizeof(data_t)) == 0)
		{
			printf("找到了%d\n", data);
			return 0;
		}
		p = p->next;
	}
	return -1;
	
}

 遍历链表(与单向链表一样)

//遍历链表
int list_showall(linklist_t* head)  //不涉及对头指针地址的修改，所以用一级指针即可
{
	linklist_t* p = head;
	if (p == NULL)
		return -1;
	while (p)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
	return 0;
}

 回收链表(与单向链表一样)

//回收链表
int list_free(linklist_t** head)
{
	linklist_t* p = *head, * q = NULL;
	while (p)
	{
		q = p;
		p = p->next;
		free(q);
	}
	*head = NULL;
	return 0;
}

附完整代码:

linklist.h

#ifndef __LINKLIST_H  //预处理用于条件编译 避免头文件反复包含
#define __LINKLIST_H

//双向链表
typedef int data_t;
typedef struct linklist
{
	data_t data;
	struct linklist* prev;
	struct linklist* next;
	
}linklist_t;

int list_create(linklist_t** head, data_t data);
int list_addhead(linklist_t** head, data_t data);
int list_insert(linklist_t** head, data_t newdata, data_t olddata);
int list_addtail(linklist_t** head, data_t data);
int list_updata(linklist_t** head, data_t olddata, data_t newdata);
linklist_t* list_find(linklist_t* head, data_t data);
int list_delete(linklist_t** head, data_t data);
int list_showall(linklist_t* head);
int list_free(linklist_t** head);
#endif

linklist.c

#include "linklist.h"
#include<stdio.h>
#include<stdlib.h>

//创建节点  输出型参数返回地址(指针)
int list_create(linklist_t** head,data_t data)  //一级指针的时候此时head还是值传递 所以需要用二级指针对head指针的地址进行传递
{
	linklist_t *p = (linklist_t*)malloc(sizeof(linklist_t)); //申请一个节点空间
	if (p == NULL)
		return -1;

	p->data = data;
	p ->next = NULL;
	p->prev = NULL;

	*head = p;  //通过对头指针解引用
	return p;
}

//在头结点插入元素(头插法)
int list_addhead(linklist_t** head, data_t data)
{
	linklist_t* p = (linklist_t*)malloc(sizeof(linklist_t));
	
	if (p == NULL)
		return -1;
	
	p->data = data;
	p->next = p ->prev = NULL;  //将要插入数据节点的后驱指向头结点的地址

	p->next = *head;  //通过对头指针解引用
	if (*head)
		(*head)->prev = p; //->的优先级大于*
	*head = p;

	return 0;
}

//中间插法
int list_insert(linklist_t** head, data_t newdata,data_t olddata)
{
	linklist_t* pnew = (linklist_t*)malloc(sizeof(linklist_t));
	if (pnew == NULL)
		return -1;
	pnew->data = newdata;
	pnew->next = pnew->prev = NULL;

	linklist_t* p = *head,*q=NULL;
	if (p == NULL)             //链表为空,用新数据创建链表
	{
		*head = pnew;
		return 0;
	}
	if (memcmp(&p->data, &olddata, sizeof(data_t)) == 0) //插入的位置为头节点位置
	{
		pnew->next = p;
		p->prev = pnew;
		*head = pnew;
		return 0;
	}
	while (p)
	{
		if (memcmp(&p->data, &olddata, sizeof(data_t)) == 0) //插入到链表中的某节点位置
		{
			pnew->next = p;
			pnew->prev = p->prev;
			p->prev->next = pnew;
			p->prev = pnew;
			return 0;
		}
		q = p;  //使用快慢指针
		p = p->next;
	}
	//未找到插入位置,将新节点尾插到链表中
	q->next = pnew;
	pnew->prev = q;
	
	return 0;
}
	

//在链表尾部插入数据(尾插法)
int list_addtail(linklist_t** head, data_t data)
{
	linklist_t* pnew = (linklist_t*)malloc(sizeof(linklist_t));
	
	if (pnew == NULL )
		return -1;
	pnew->data = data;
	pnew->next = pnew->prev = NULL;

	
	linklist_t* p = *head,*q=NULL; //利用快慢指针  要对head解引用
	if (p == NULL)
	{
		*head = pnew; //p为空，则head链表是空链表，所以将要插入的节点就为头节点
		return 0;
	}
	//遍历链表
	while (p->next)
	{
		p = p->next;
	}
	p->next = pnew;
	pnew->prev = p;
	return 0;
}

//修改数据
int list_updata(linklist_t** head, data_t olddata,data_t newdata)
{
	linklist_t* p = *head;
	if (p == NULL)
		return -1;
	while (p)
	{
		if (memcmp(&p->data, &olddata, sizeof(data_t)) == 0)
		{
			p->data = newdata;
			return 0;
		}
		p = p->next;
	}
	return -1;
}

//查找数据
linklist_t* list_find(linklist_t* head, data_t data)
{
	linklist_t* p = head;
	if (p == NULL)
		return -1;
	while (p)
	{
		if (memcmp(&p->data, &data, sizeof(data_t)) == 0)
		{
			printf("找到了%d\n", data);
			return 0;
		}
		p = p->next;
	}
	return -1;
	
}

//删除节点
int list_delete(linklist_t** head, data_t data)
{
	linklist_t* p = *head;
	if (p == NULL)
		return -1;
	if (memcmp(&p->data, &data, sizeof(data_t)) == 0) //删除的是头节点
	{
		if (p->next == NULL) //头节点是唯一的节点
		{
			*head = NULL;
			
		}
		else //头节点不是唯一的节点
		{
			p->next->prev = NULL;
			*head = p->next;
		}
		free(p);
		return 0;
	}
	while (p)  //进入循环后表示删除的不是头节点
	{
		if (memcmp(&p->data, &data, sizeof(data_t)) == 0) //数据找到
		{
				p->prev->next = p->next;
			if(p->next) //删除的不是尾节点
				p->next->prev = p->prev;
			else //删除的是尾节点
			{
				p->prev->next = NULL;
			}
			free(p);//删除
			return 0;
		}
		p = p->next;
	}
	return -1;
}

//回收链表
int list_free(linklist_t** head)
{
	linklist_t* p = *head, * q = NULL;
	while (p)
	{
		q = p;
		p = p->next;
		free(q);
	}
	*head = NULL;
	return 0;
}

//遍历链表
int list_showall(linklist_t* head)  //不涉及对头指针地址的修改，所以用一级指针即可
{
	linklist_t* p = head;
	if (p == NULL)
		return -1;
	while (p)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
	return 0;
}

main.c

#pragma warning(disable:4996)
#include "linklist.h"  //不能多次重复包含 会报错
#include<stdio.h>

int main()
{
	linklist_t* head = NULL;
	list_create(&head,321); //接收指针的地址
	list_addhead(&head, 666);//头插法
	//中间插法
	list_addtail(&head, 222);  //尾插法
	list_addtail(&head, 888);
	list_addtail(&head, 999);
	list_showall(head); //遍历链表

	list_find(head,666);
	/*while (1)
	{
		data_t data;
		printf("请输入要删除的数据(-1退出):\n");
		scanf("%d", &data);
		if (data == -1)
			break;
		if (-1 == list_delete(&head, data))
		{
			printf("删除的数据不存在，请重试...\n");
			continue;
		}
		list_showall(head); //遍历链表
	}
	*/
	while (1)
	{
#if 0  //预处理条件编译
		data_t data;
		printf("请输入要删除的数据(-1退出):\n");
		scanf("%d", &data);
		if (data == -1)
			break;
		if (-1 == list_delete(&head, data))
		{
			printf("删除的数据不存在，请重试...\n");
			continue;
		}
		list_showall(head); //遍历链表
#else
		data_t olddata,newdata;
		printf("请输入要在那个数据前插入(-1退出):\n");
		scanf("%d", &olddata);
		if (olddata == -1)
			break;
		printf("请输入插入的数据(-1退出):\n");
		scanf("%d", &newdata);
		if (-1 == list_insert(&head, newdata, olddata))
		{
			printf("数据插入失败，请重试...\n");
			continue;
		}
		list_showall(head); //遍历链表
#endif
	}
	list_free(&head); //回收链表

	return 0;
}

懒大王就是我
关注
  • 9
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构10分钟入门--单链表
wszdezh123的博客
09-08 453
链表是一种通过指针串联在一起的线性结构，在内存中是分散存储的（数组在内存中连续分布），链表由一系列节点组成，每个节点都由数据域和指针域组成
数据结构链表入门.docx
01-13
《数据结构链表入门》 链表是一种基础且重要的数据结构，在计算机科学中扮演着不可或缺的角色。本资料主要介绍链表的基本概念、操作以及如何在C++中实现链表。以下将详细阐述链表的原理及其在代码中的体现。 1. ...
数据结构入门链表篇
descire
01-26 772
141. 环形链表  给你一个链表的头节点 head ，判断链表中是否有环。  如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测...
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 40万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
数据结构（入门篇）
lovelife000的博客
06-18 1195
数据结构入门篇
数据结构笔记——链表
关于我的学习记录
12-05 2185
数据结构笔记——链表
数据结构之链表基础入门理解
chenhuandong1234的博客
02-28 596
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基 //第一个小小链表建立 #include&
数据结构入门指南：链表（新手避坑指南）
2202_75605090的博客
07-30 5987
前边我们学习了顺序表，顺序表是数据结构中最简单的一种线性数据结构，今天我们来学习链表，难度相较于顺序表会大幅增加，非常考验大家对结构体、指针的理解。但是也不要害怕，我会一一向大家解答疑惑，本期的内容先给初学者预预热，主要介绍在刚开始实现链表时注意的点以及逻辑基础，下期会将功能接口具体实现。}SLNode;定义链表这里就迎来了第一个坑，上述的这种形式很常见，对于初学者来说这里就有一个坑，这个链表定义的是否正确呢？这种方式是不正确的，为什么？
【数据结构基础】之链表介绍，生动形象，通俗易懂，算法入门必看
小新要变强的博客
11-01 965
链表是一种动态数据结构，他的特点是用一组任意的存储单元（可以是连续的，也可以是不连续的）存放 数据元素；链表中每一个元素成为 “结点” ， 每一个结点都是由数据域和指针域组成的， 每个结点中的指针域指向下一 个结点。本文将对链表的概念与特点，单链表，双链表，循环链表，链表的封装，Java中链表的使用进行详细介绍~
LeetCode_数据结构入门_反转链表
木木生琳的博客
01-27 380
反转链表 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。 示例 1： 输入：head = [1,2,3,4,5] 输出：[5,4,3,2,1] 示例 2： 输入：head = [1,2] 输出：[2,1] 示例 3： 输入：head = [] 输出：[] （上述题目来源与LeetCode） 解法（递归反转链表）： /** * Definition for singly-linked list. * public class ListNode { * int val; *
【高阶篇】3.8 Redis之底层数据结构链表包(listpacks)详解
日拱一卒无有尽，功不唐捐终入海
06-16 1123
本文将Redis底层数据结构 listpacks（链表包）详解，它用于实现列表数据类型。listpacks是一种紧凑的连续内存块，其设计目标是减少内存的占用，通过紧凑的内存布局和多种数据类型的编码方式，提供了高效的插入和删除操作。| zlbytes | 4字节，列表总字节数| zltail | 4字节，列表尾节点偏移量| zllen | 2字节，列表节点数量。
数据结构从入门到精通-链表
03-05
双向循环链表
数据结构_链表的分类_数据结构_
10-02
数据结构C语言的入门，数据链表的分类，能够帮助你学习数据结构
数据结构入门题目(力扣)
03-09
记录自己14天在力扣的数据结构入门的做题过程,部分解题思路是自己想出来的,部分是参考了对应题目的评论区网友的思路. 入门题目有:存在重复元素,最大子数组和,两数之和,合并两个有序数组,两个数组的交集 II,买卖股票...
数据结构入门基础1
08-08
在本课程“数据结构入门基础1”中，我们将探讨多种数据结构及其在不同领域的应用。 1. **线性结构**：线性结构是数据结构的基础，包括数组、栈、队列、链表和哈希表。数组是最基本的数据结构，它提供了随机访问和...
LeetCode刷题之HOT100之数组中的第K个最大元素
我的树洞
06-29 317
2024 6/29 今天天气很好啊，想爬山，奈何下午还有最后的一个汇报。做个题先。
数据结构-第七章（树型查找）
2203_75970230的博客
06-29 769
为了保证AVL树的平衡性，我们在插入删除时频繁地调整全树整体的拓扑结构，代价较大。(从目的入手，更好深入）因此，我们对二叉排序树不再进行高度平衡的限制(AVL树)，而进行适度平衡的限制(红黑树)。这样在保证查找效率的同时我们进行插入删除操作所付出的代价也更小，因此红黑树的实际应用更广泛，C++中的map和set(Java中的TreeMap和TreeSet)就是用红黑树实现的。一棵红黑树是满足如下红黑性质的二叉排序树:每个结点或是红色，或是黑色的。根结点是黑色的。
RStudio学习笔记（三）：其他数据结构
weixin_58351753的博客
06-29 194
在R语言中，数据结构有向量、矩阵、数组、列表、因子等，有些数据结构与其他编程语言的定义存在一定的区别。
从零开始学数据结构系列之第三章《哈夫曼编码构造及代码》
最新发布
铁匠匠匠的博客
06-30 650
哈夫曼编码首先会使用字符的频率创建一棵树，然后通过这个树的结构为每个字符生成一个特定的编码，出现频率高的字符使用较短的编码，出现频率低的则使用较长的编码，这样就会使编码之后的字符串平均长度降低，从而达到数据无损压缩的目的。而带权路径长度是指：树中所有的叶子节点的权值乘上其到根节点的路径长度，这与最终的哈夫曼编码总长度成正比关系的。这是因为在哈夫曼树中，每个字母对应的节点都是叶子节点，而他们对应的二进制码是由根节点到各自节点的路径所决定的，正因为是叶子节点，每个节点的路径不可能和其他节点有前缀的关系。
数据结构与算法入门需要学习什么
04-27
学习数据结构与算法入门需要掌握以下内容： 1. 数据结构的基本概念和分类，如数组、链表、栈、队列、树、图等。 2. 数据结构的基本操作，如插入、删除、查找、排序等。 3. 算法的基本概念和分类，如贪心、动态规划、分治、回溯等。 4. 熟练掌握常用的算法和数据结构，如二分查找、快速排序、堆排序、哈希表、并查集等。 5. 学习算法和数据结构的时间和空间复杂度分析，了解如何评估算法的效率和优劣。 6. 刷题是学习算法和数据结构的重要方式，需要多做算法题，掌握算法思想和实现方法。 7. 学习算法和数据结构的过程中，需要注重实践和思考，多动手实现算法，理解其原理和实现细节。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值