2022-03-21_双链表的增删查改(带目录版)

最新推荐文章于 2024-11-11 20:46:27 发布
最新推荐文章于 2024-11-11 20:46:27 发布
阅读量1.4k 收藏
点赞数
分类专栏： C语言编程题 文章标签： c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43205256/article/details/123756523
版权

题目名称：

双链表的增删查改

题目内容：

带头+双向+循环链表增删查改实现

第一步 创建三个文件

第二步 代码实现

1.List.c部分

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#include <ctype.h>
#include <assert.h>
#include <stdbool.h>
#include "List.h"



enum Option
{
	退出链表,
	头插,
	头删,
	尾插,
	尾删,
	随机插值,
	删除数值,
	查找数值,
	打印链表
};



void menu()
{
	printf("*****************************************\n");
	printf("******     1.头插       2.头删     ******\n");
	printf("******     3.尾插       4.尾删     ******\n");
	printf("******     5.随机插值   6.删除数值 ******\n");
	printf("******     7.查找数值   8.打印链表 ******\n");
	printf("******     0.退出链表              ******\n");
	printf("*****************************************\n");
}



int main()
{
	LN* pList = NULL;
	ListInit(&pList);
	int input = 0;
	do
	{
		menu();
		printf("请输入要进行的操作：");
		scanf("%d", &input);
		switch (input)
		{
		case (头插):
			ListPushFrant(pList);
			break;
		case (头删):
			ListPopFrant(pList);
			break;
		case (尾插):
			ListPushBack(pList);
			break;
		case (尾删):
			ListPopBack(pList);
			break;
		case (随机插值):
			ListInsert(pList);
			break;
		case (删除数值):
			ListErase(pList);
			break;
		case (查找数值):
			ListFind(pList);
			break;
		case (打印链表):
			ListPrint(pList);
			break;
		case (退出链表):
			ListDestroy(pList);
			break;
		default:
			printf("输入有误，请重新输入\n");
			break;
		}
	} while (input);
	return 0;
}

2.List.h部分

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#include <ctype.h>
#include <assert.h>
#include <stdbool.h>


//1.定义结构体
typedef struct ListNode
{
	int data;
	struct ListNode* next;
	struct ListNode* prev;
}LN;



//2.获得新节点函数声明
LN* BuyLTNode(LN* pList);



//3.初始化结构体函数声明
void ListInit(LN** ppList);


//4.插入函数声明
void ListInsert(LN* pList);



//5.打印函数声明
void ListPrint(LN* pList);


//6.回收链表函数声明
void ListDestroy(LN* pList);


//7.头插函数声明
void ListPushFrant(LN* pList);


//8.头删函数声明
void ListPopFrant(LN* pList);


//9.尾插函数声明
void ListPushBack(LN* pList);


//10.尾删函数声明
void ListPopBack(LN* pList);


//11.删除节点函数声明
void ListErase(LN* pList);


//12.查找函数节点声明
void ListFind(LN* pList);

3.ListFunc.c部分

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#include <ctype.h>
#include <assert.h>
#include <stdbool.h>
#include "List.h"


//2.获得新节点函数实现
LN* BuyLTNode(int x)
{
	LN* newnode = (LN*)malloc(sizeof(LN));
	if (newnode == NULL)
	{
		printf("BuyLTNode::()%s\n", strerror(errno));
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	newnode->prev = NULL;
	return newnode;
}



//3.初始化结构体函数实现
void ListInit(LN** ppList)
{
	assert(ppList);
	*ppList = BuyLTNode(0);
	(*ppList)->next = *ppList;
	(*ppList)->prev = *ppList;
}



//4.插入函数实现
void ListInsert(LN* pList)
{
	assert(pList);
	if (pList->next == pList)
	{
		printf("暂无节点，请输入数值进行插值：");
		int x = 0;
		scanf("%d", &x);
		LN* newnode = BuyLTNode(x);
		newnode->next = pList;
		newnode->prev = pList;

		pList->next = newnode;
		pList->prev = newnode;
	}
	else
	{
		printf("请输入要在哪个数值前面插值：");
		int y = 0;
		scanf("%d", &y);
		LN* cur = pList->next;
		while (cur != pList)
		{
			if (cur->data == y)
			{
				break;
			}
			cur = cur->next;
		}
		if (cur == pList)
		{
			printf("无此节点，请重新输入：\n");
			return;
		}
		printf("请输入要插入的值：");
		int val = 0;
		scanf("%d", &val);
		LN* newnode = BuyLTNode(val);
		newnode->prev = cur->prev;      //与前节点连接
		cur->prev->next = newnode;

		newnode->next = cur;            //与后节点连接
		cur->prev = newnode;
	}
	printf("插入数值成功!\n");
}



//5.打印函数实现
void ListPrint(LN* pList)
{
	assert(pList);
	LN* cur = pList->next;
	while (cur != pList)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}



//6.回收链表函数实现
void ListDestroy(LN* pList)
{
	assert(pList);
	LN* Cur = pList->next;
	LN* CurNext = Cur->next;
	while (Cur != pList)
	{
		CurNext = Cur->next;                //先保存下一个节点

		Cur->next = NULL;
		Cur->prev = NULL;
		free(Cur);
		Cur = NULL;

		Cur = CurNext;               
	}
	pList->next = NULL;
	pList->prev = NULL;
	free(pList);
	pList = NULL;
	printf("回收空间成功，退出链表\n");
}



//7.头插函数实现
void ListPushFrant(LN* pList)
{
	assert(pList);
	printf("请输入要头插的数值：");
	int x = 0;
	scanf("%d", &x);
	LN* newnode = BuyLTNode(x);
	newnode->next = pList->next;     //与后节点连接
	pList->next->prev = newnode;

	newnode->prev = pList;           //与哨兵位连接
	pList->next = newnode;
	printf("头插函数成功!\n");
}



//8.头删函数实现
void ListPopFrant(LN* pList)
{
	assert(pList);
	if (pList->next == pList)
	{
		printf("无节点，无法头删\n");
		return;
	}
	LN* pos = pList->next;

	pList->next->next->prev = pList;
	pList->next = pList->next->next;

	pos->next = NULL;
	pos->prev = NULL;
	free(pos);
	printf("头删成功!\n");
}



//9.尾插函数实现
void ListPushBack(LN* pList)
{
	assert(pList);
	printf("请输入要尾插的数值：");
	int x = 0;
	scanf("%d", &x);
	LN* newnode = BuyLTNode(x);
	newnode->prev = pList->prev;
	pList->prev->next = newnode;

	newnode->next = pList;
	pList->prev = newnode;
	printf("尾插成功!\n");
}



//10.尾删函数实现
void ListPopBack(LN* pList)
{
	assert(pList);
	if (pList->next == pList)
	{
		printf("无节点，无法尾删\n");
		return;
	}
	LN* pos = pList->prev;
	pList->prev->prev->next = pList;
	pList->prev = pList->prev->prev;

	pos->next = NULL;
	pos->prev = NULL;
	free(pos);
	printf("尾删成功!\n");
}



//11.删除节点函数实现
void ListErase(LN* pList)
{
	assert(pList);
	if (pList->next == pList)
	{
		printf("无节点，无法删除\n");
		return;
	}
	printf("请输入要删除的数值：");
	int x = 0;
	scanf("%d", &x);
	LN* cur = pList->next;
	while (cur != pList)
	{
		if (cur->data == x)
		{
			break;
		}
		cur = cur->next;
	}
	if (cur == pList)
	{
		printf("无该节点，无法删除\n");
		return;
	}
	cur->next->prev = cur->prev;
	cur->prev->next = cur->next;

	cur->next = NULL;
	cur->prev = NULL;
	free(cur);
	printf("删除节点成功\n");
}



//12.查找函数节点实现
void ListFind(LN* pList)
{
	assert(pList);
	if (pList->next == pList)
	{
		printf("无节点，无法查找\n");
		return;
	}
	printf("请输入要查找的数值：");
	int x = 0;
	scanf("%d", &x);
	LN* cur = pList->next;
	while (cur != pList)
	{
		if (cur->data == x)
		{
			break;
		}
		cur = cur->next;
	}
	if (cur == pList)
	{
		printf("无该节点\n");
		return;
	}
	printf("数值%d的地址为%p\n", x, cur);
}

 

happy 天堂
关注
专栏目录
【数据结构】---单链表____增删查改
weixin_52563203的博客
07-29 457
单链表概念，结构，功能
双向链表的增删查改
weixin_69081438的博客
08-05 813
双向链表详解
双向链表增删改查C语言代码,实现双向链表提供增删改查
weixin_31512775的博客
05-21 334
MyLinkedList.java后期会添加更多操作/*** 双向链表* 对外提供CRUD** 链表索引起点：0*/class MyLinkedList {private Node head;// 头结点，可变化。管理链表的核心。private Node tail;// 尾节点的引用。private int size;// 链表节点的个数// 初始化public MyLinkedList() {h...
单链表的创建和添加元素(具体代码实现) [数据结构][Java]
m0_57001006的博客
08-18 500
null) 循环退出之后temp指向了链表中最后一个元素的位置。= null) 循环退出之后temp指向了链表中最后一个节点的下一个位置。temp = head 或者 temp = head.next等等都是指明从哪个结点开始。while循环的循环控制添加则是判断中间的的过程是如何执行的,以及从哪个结点结束。...
双链表的增删改查
qq_62548337的博客
04-09 518
import org.junit.Test; import java.util.*; /** * @author ztyOperation * @create 2022-04-05-22:13 */ public class DoubleLinkedList { public static void main(String[] args) { //测试 //增加s PersonList list = new PersonList()...
双向链表的增删改查
weixin_44695544的博客
06-13 721
线性结构-双向链表的增删改查
双链表的增删改查（c语言）
weixin_46323638的博客
03-28 1858
链表的分类 1：单向或双向 2：带头或不带头 3： 循环或非循环 此上所属种类便可组成八种不同的链表，但其实最常用的链表也就两种： 1：无头单项非循环链表 结构简单，不会单独用来存储数据，更偏向于作为其他数据结构的子结构。 2：带头双向循环链表 结构复杂，一般用来单独存储数据，一般实际使用的链表都是双向带头循环链表。 双向带头链表的实现： 双向循环链表的节点由三部分组成： 节点的创建： typedef int LTDataType; typ...
顺序表 链表 双链表的增删查改操作及链表逆置等常用线性表算法.zip
08-16
在本压缩包中，我们重点关注了三种类型的线性表：顺序表、链表和双链表，以及它们的增删查改操作和链表逆置等常见算法。 顺序表是一种最简单的线性表实现，它在内存中是连续存储的，可以通过数组来表示。对于顺序表...
《数据结构C语言版》-双链表的增删查改,链表与顺序表的区别
记录这一刻。
04-08 1265
《数据结构C语言版》-双链表的增删查改,链表与顺序表的区别，简单易懂，轻松掌握。
双链表的增删查改实现（c语言描述）
未见花闻的博客
07-12 629
内容导读 1.什么是双链表 1.1 双链表概述 1.2循环链表 1.3双链表的优点 2.双链表的定义以及常见功能的实现 2.0双链表定义以及常见功能头文件 2.1双链表定义（声明） 2.2双链表内存申请及扩容 2.3双链表初始化 2.4双链表的打印 2.5双链表的插入与删除操作理论 2.6双链表头插操作代码实现 2.7双链表尾插操作代码实现 2.8双链表的位置pos（已知）前插入操作代码实现 2.9双链表的头删操作代码实现 2.10双链表尾删操作代码实现 2.11双...
【数据结构】带头双向循环链表的增删查改（C语言实现）
在平淡的日子里寻找存在的价值
08-08 1413
带头双向循环链表的实现以及链表、顺序表优缺点的总结。
xsd 节点可循环_数据结构Java实现：循环链表和双向链表
weixin_39785400的博客
12-03 118
Java大联盟 致力于最高效的Java学习关注上篇教程给大家分享了单链表的概念，以及如何用 Java 实现一个单链表的结构：数据结构Java实现：单链表。单链表是最基础的一种链表结构，在实际开发中的使用有一些局限性，比如只能单向往后查找节点，如果需要找到某元素的前驱节点，单链表是无法实现的，今天来给大家分享另外两个复杂一些的链表结构：循环链表和双向链表。循环链表循环链表本质上就是一...
数据结构 链表【链表的回收】
Kukeoo的博客
02-20 1251
链表的回收 众所周知，在堆区开辟的空间，需要由程序员自己释放。 而我们初始化链表，建立链表，对其进行插入、删除、查找等操作后，动态开辟的空间并没有被释放掉， 所以我们写一个链表回收的函数。 由于链表是由指针链起来的，很容易出现断链， 所以我们需要借助一个临时指针变量ret，来帮助我们进行逐点回收。 先看一个小例子： int a = 10; int b = 20; int* pa = &a; int* p = pa; cout << pa << end
java实现双向链表的增删改查
日常笔记 | 干货分享 | 毕设源码 | 毕设指导 | 答辩指导
08-17 703
双向链表的增删改查 基本结构 1、增加操作 1、链接cur与pre和next，其中的next是pre的下一个节点 2、用cur重新连接 在尾部添加代码实现 //添加 从尾部添加 public void addEnd(Student1 student1){ Student1 temp=head1;//辅助 while(true){ if(temp.next==null){ break;
springboot的增删改查商城小实践（b to c）
m0_68728226的博客
11-06 1013
一种是将光标防止需要生成set和get方法的属性值上，然后按“ALT + ENTER”键，在弹出的栏位中选择”Create getter and setter for ***“，一个属性值一个属性值的生成get和set方法。另一种是按“ALT + INSERT”键，打开Generate弹框，在Generate弹框中选择“Getter and Setter”即可打开get和set方法生成窗口，在窗口中选择需要生成的属性值，单击OK即可。IDEA代码生成Generate。
【数据结构】C语言二叉树中求度为2的结点的个数、交换二叉树的左右子树、二叉树中先序输出各结点及其层次
最新发布
samroom的博客
11-11 349
编写算法，在以二叉链表存储的二叉树中，按先序次序输出各结点的内容及相应的层次数，要求以二元组的形式输出。（输出格式参见样例）编写算法，在以二叉链表存储的二叉树中，交换二叉树各结点的左右子树。编写算法，在以二叉链表存储的二叉树中，求度为2的结点的个数。
SystemVerilog学习笔记（八）：循环
qq_38156104的博客
11-11 587
循环只不过是将需要多次运行的语句包含在循环中，而不是重复编写这些语句。循环将根据条件语句运行多次，如果条件始终为真，则它会变成无限循环，系统将挂起。
数据结构-查找以及效率分析
dametime_的博客
11-11 127
将被查概率高的放到靠前位置,可以提高查找成功的效率,但对于查找失败的情况需要从头看到尾,因为无序排列,根据实际情况选择不同的方式,经常查找成功可以考虑上图方式。折半查找的查找效率,绿色节点为查找成功,紫色为查找失败,一共11个结点,每一层结点的数量*查到该层结点需要的步数的综合/11就是成功的ASL,失败同理。因为右子树的节点数一定比左子树多1个或等于左子树的结点,所以当两个数折半查找,画出查找判断树,2结点在右子树。所以要想算出他们的查找效率,我们需要画出来对应的查找判定树(根据折半查找的思想画图)
双链表的增删查改的时间复杂度
04-04
双链表的时间复杂度如下： 1. 增加节点：O(1) 在双链表的任何位置插入新节点，只需要修改前后节点的指针，时间复杂度为O(1)。 2. 删除节点：O(1) 删除节点同样只需要修改前后节点的指针，时间复杂度为O(1)。 3. 查找节点：O(n) 双链表无法像数组一样直接根据下标查找元素，需要遍历整个链表才能找到目标节点。因此，查找一个节点的时间复杂度为O(n)。 4. 修改节点：O(n) 修改一个节点需要先找到该节点，因此时间复杂度与查找节点相同，为O(n)。然后需要修改节点的值，这个操作时间复杂度为O(1)。因此，总的时间复杂度为O(n)。 综上所述，双链表的增删查改的时间复杂度分别为O(1)、O(1)、O(n)和O(n)。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值