双向链表的代码设计

最新推荐文章于 2024-11-08 14:00:00 发布
最新推荐文章于 2024-11-08 14:00:00 发布
阅读量268 收藏
点赞数 7
文章标签： 链表 数据结构 c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59990833/article/details/139885585
版权

设计内容

设计并编程实现一个双向链表，首先显示一个菜单并且实现以下功能

  1. 创建一个双向链表
  2. 增加结点（能在任意位置增加）
  3. 删除结点（能删除任意位置结点）
  4. 修改结点
  5. 查询结点（根据位置查内容或根据内容查位置）
  6. 显示所有结点内容（正向显示及方向显示）
  7. 退出
运行代码
1.main.c代码
#include<stdio.h>
#pragma warning(disable:4996)
#include"func.h"
void show_menu()
{
	printf("1、创建一个双向循环链表\n");
	printf("2、增加结点\n");
	printf("3、删除结点\n");
	printf("4、修改结点内容\n");
	printf("5、查询结点内容\n");
	printf("6、显示所有结点内容\n");
	printf("7、退出\n");

}
int main()
{
	node* head = creatlist();
	int listnum;
	//初始化一个头节点
	int data;
	int position;
	while (1)
	{
		show_menu();
		int slect;
		scanf_s("%d", &slect);
		
	
			switch (slect)
			{
			case 1:
				printf("输入链表中的结点数: ");
				int n;
				scanf_s("%d", &n);
				for (int i = 0; i < n; i++) {
					printf("输入第 %d 个结点的数据: ", i + 1);
					scanf_s("%d", &data);
					append(head, data);
				}
				printf("链表创建成功\n");
				break;
			case 2://任意位置插入数据
				printf("输入要添加的数据：");
				scanf_s("%d", &data);
				printf("输入要添加的位置：");
				scanf_s("%d", &position);
				listnum = sizelist(head);
				//printf("%d", listnum);
				if (position <= listnum + 1)
				{
					listinsert(head, data, position);
				}
				else
				{
					printf("超出链表位置的大小\n");
					break;
				}
				break;
			case 3://删除
				printf("输入要删除的位置");
				scanf_s("%d", &position);
				listnum = sizelist(head);
				//printf("%d", listnum);
				if (position <= listnum + 1)
				{
					deletelist(head, position);
				}
				else
				{
					printf("超出链表位置的大小\n");
					break;
				}
				break;
			case 4://修改
				printf("输入要修改的值：");
				scanf_s("%d", &data);
				printf("输入要修改的位置");
				scanf_s("%d", &position);
				listnum = sizelist(head);
				if (position <= listnum)
				{
					modify(head, position, data);
					printf("修改成功\n");
				}
				else
				{
					printf("输入的值大于链表位置的大小\n");
					break;
				}

				break;
			case 5://查询
				printf("请输入要查找的方式：按位置查找：1，按值查找：2\n");
				scanf_s("%d", &slect);
				listnum = sizelist(head);
				if (slect == 1)
				{
					printf("请输入要查询的位置:\n");
					scanf_s("%d", &position);
					if (position <= listnum)
					{
						int num = search(head, position);
						printf("查询第个%d位置的是值为：%d\n", position, num);
					}
					else
					{
						printf("输入的值大于链表位置的大小\n");
						break;
					}

				}
				else if (slect == 2)
				{
					printf("请输入要查找的值\n");
					scanf_s("%d", &data);
					position = searchdata(head, data);
					if (position == NULL)
					{
						printf("查无此值\n");
						break;
					}
					else
					{
						printf("查找的%d值的位置为：%d\n", data, position);
					}
				}
				else
				{
					printf("无法查找结点，请重新输入：\n");
					break;
				}
				break;
			case 6://显示结点内容
				printf("请输入打印方式：正序为:1,反序为:2\n");
				scanf_s("%d", &slect);

				if (slect == 1)
				{
					showlistnode(head);
				}
				else if (slect == 2)
				{
					showlistnodefor(head);
					printf("\n");
				}
				else
				{
					printf("无法打印结点，请重新输入：\n");
					break;
				}
				break;
			case 7://退出
				printf("退出系统成功");
				exit(0);
				break;
			default:
				printf("输入的数字有误，请重新输入\n");
				break;
			}
			/*system("pause");
			system("cls");*/
		
	}
}
2.func.c代码
#include<stdlib.h>
#include"func.h"
#include<string.h>
#include<stdio.h>
//初始化头结点
node* creatlist()
{
	node* head = (node*)malloc(sizeof(node));
	if (head == NULL)
	{
		printf("malloc error");
		return NULL;
	}
	else
	{
		head->next = head;
		head->pre = head;
		return head;
	}
}
//添加结点---本质就是顺序添加
void append(node* head, int data)
{
	node* newnode = (node*)malloc(sizeof(node));

	if (newnode == NULL)
	{
		printf("malloc error");
		return;
	}
	else
	{
		newnode->data = data;
		if (head->next==head&&head->pre==head)
		{
			head->next = newnode;
			newnode->pre = head;
			newnode->next = head;
			head->pre = newnode;
		}
		else
		{
			node* lastnode = head->pre;
			lastnode->next = newnode;
			newnode->pre = lastnode;
			newnode->next = head;
			head->pre = newnode;
			//return head;
			///*node* last = head->pre;
			//last->next = newnode;
			//newnode->pre = last;
			//newnode->next = head;
			//head->pre = newnode;*/
		}
	}
	
}
//任意位置插入
void listinsert(node* head, int data, int position)
{
	int count = 0;
	if (head->next==head&&head->pre==head)
	{
		append(head, data);
		return;
	}
	else
	{
		//如果为空，直接添加
		node* newnode = (node*)malloc(sizeof(node));
		if (newnode == NULL)
		{
			printf("malloc error");
		}
		else
		{
			newnode->data = data;

			//头部插入数据
			if (position == 0 || position == 1)
			{
				node* nextnode = head->next;
				head->next = newnode;
				newnode->pre = head;
				newnode->next = nextnode;
				nextnode->pre = newnode;

			}
			else
			{
				node* current = head;
				int count = 0;
				//查找到目标位置的前一个结点
				while (count < position - 1)
				{
					current = current->next;
					count++;
				}
				node* nextnode = current->next;
				current->next = newnode;
				newnode->pre = current;
				newnode->next = nextnode;
				nextnode->pre = newnode;

			}
		}
		
	}
	

}
//修改这个值
void modify(node* head, int position, int data)
{
	if (head->next==head&&head->pre==head)
	{
		printf("链表为空，无法删除结点\n");
		return;
	}
	node* currrnt = head;
	int count = 0;
	while (count<position)
	{
		currrnt = currrnt->next;
		count++;
	}
	currrnt->data = data;
}
//删除结点
void deletelist(node* head, int positiom)
{
	if (head ->next==head&&head->pre==head)
	{
		printf("链表为空，无法删除\n");
		return;
	}
	
	if (positiom==1||positiom==0)
	{
		node* current = head->next;
		if (current->next ==head)//说明只有一个结点
		{
			
			head->next= head;
			head->pre = head;
			free(current);
		
		}
		else//不是一个结点
		{
		
			node* nextnode = current->next;
			head->next = nextnode;
			nextnode->pre = head;
				free(current);
		}
	}
	else
	{
		node* current = head;
		int count = 0;
		while (count < positiom)
		{
			current = current->next;
			count++;
		}//current为需要删除的位置
		if (current->next ==head)
		{
			node* fornode = current->pre;
			fornode->next = head;
			head->pre = fornode;
			free(current);
		}
		else
		{
			node* fornode = current->pre;
			node* nextnode = current->next;
			fornode->next = nextnode;
			nextnode->pre = fornode;
			free(current);
		}
	}
}
//顺序显示显示链表内容
void showlistnode(node* phead)
{
	if (phead->next&&phead->pre==phead)
	{
		printf("链表为空\n");
		return;
	}
	else
	{
			node* cur = phead->next;
			do
			{
				printf("%d ",cur->data);
				cur = cur->next;
			} while (cur!=phead);
	
			printf("\n");
	}
		
}
//倒序显示
void showlistnodefor(node* phead)
{
	if (phead->next == phead && phead->pre == phead)
	{
		printf("链表为空");
		return NULL;
	}
	else
	{
		node* cur = phead->pre;
		do
		{
			printf("%d ", cur->data);
			cur = cur->pre;
		} while (cur!=phead);
		

	}
}
//按位置查找结点
int search(node* head, int position)
{
	if (head ->next==head&&head->pre==head)
	{
		printf("链表为空\n");
		return NULL;
	}
	node* current = head;
	int count = 0;
	while (count < position)
	{
		current = current->next;
		count++;
	}
	return current->data;
}

//按值查找
int searchdata(node* head, int data)
{
	if (head->next == head && head->pre == head)
	{
		printf("链表为空\n");
		return NULL;
	}
	node* current = head->next;
	int position = 1;
	while (current->data!=data)
	{
		current = current->next;
		position++;
		if (current == head)
		{
			
			return NULL;
		}
	}
	return position;
}
//计算节点的大小
int sizelist(node* head)
{
	node* current = head->next;
	int count = 0;
	while (current!=head)
	{
		count++;
		current = current->next;
	}
	return count;
}
3.func.h代码
#pragma once
#ifndef FUNC_H
#define FUNC_H
#include<assert.h>
typedef struct node
{
	struct node* pre;
	int data;
	struct node* next;
}node;
//申请节点
node* buynode(int data);
//初始化头
node* creatlist();
//添加结点
void append(node* head, int data);
//打印结点
void showlistnode(node* phead);
//倒序打印
void showlistnodefor(node* phead);
//插入结点
void listinsert(node* head, int data, int position);
//修改结点内容
void modify(node* head, int position, int data);
//删除结点
void deletelist(node* head, int positiom);

//查找结点
int search(node* head, int position);
//按值查找
int searchdata(node* head, int data);

//计算节点的大小;
int sizelist(node* head);
#endif // !FUNC_H

指针、数组
关注
数据结构之双向链表详解
小源_ 的博客
12-20 3647
本文着重讲解了LinkedList(无头双向单链表)的实现和LinkedList的使用。内附代码和图文分析，看完就会！
什么是双向链表，一篇搞懂双向链表
hahaha_1112的博客
03-12 1063
双向链表，python3
数据结构 --- c语言实现双向链表
weixin_60569662的博客
07-07 2741
双向链表主要分为三部分前项指针后项指针数据域一般情况下，创建单一个体，前项指针和后项指针都赋值为空一般采用记录头节点和记录尾节点，再封装的方式写双向链表 再定义一个结构体(链表) 通过记录头节点和尾节点的方式去描述链表 创建节点 把用户的数据变成一个结构体变量 创建链表 描述链表最初的状态 头插法 ①新节点的后项指针指向原来链表的头节点②原来链表的头节点的前项指针指向新节点③把原来的头节点移到新节点的位置 打印链表 可以通过前项指针去做打印，也可以通过后项
C语言双向链表的实现
m0_63666616的博客
05-03 4839
双向链表简介 我们知道，单链表（singly linked list）只有一个指向直接后继的指针来表示结点间的逻辑关系，可以方便地查找下一个结点，但是找前驱结点就非常困难。这时，我们就需要用上双向链表(doubly linked list)来解决这个问题。 结构体构建 第一个动作和单链表类似，我们使用结构体来定义出这种数据类型。代码： typedef struct DLinkNode{ int data; struct DLinkNode *prev; struct DLinkNode *next;
数据结构 - 双向链表
weixin_73869209的博客
09-07 1365
如上图所示,双向链表中包含了两个指针,一个指向前驱结点,一个指向后继节点,其中头结点没有前驱节点,尾结点没有后继节点前驱: 前驱指的是当前节点的前一个节点，即在链表中位于当前节点之前的节点。它可以通过前向指针（previous pointer）来访问。后继: 后继指的是当前节点的后一个节点，即在链表中位于当前节点之后的节点。它可以通过后向指针（next pointer）来访问。这篇博客大家应重点关注链表的设计,代码这个东西面试考的更多的是单链表,大家刷题更多的也是单链表,双向链表相对于就没有那么重要了。
双向链表代码
11-30
在计算机科学中，数据结构是组织和管理大量数据的关键...掌握双向链表的使用是理解和实现复杂数据结构的基础，它在算法设计和实际编程中都有广泛的应用，例如在LRU缓存淘汰策略、文件系统、编译器符号表管理等方面。
创建双向链表_双向链表_
09-30
双向链表是一种特殊类型的数据结构，与常见的单向链表相比，它具有更丰富的操作能力，可以支持前后两个方向的遍历。本篇文章将深入探讨如何创建双向链表以及其在增加和删除操作中的应用。 双向链表的每个节点不仅...
双向链表设计
sifanchao的博客
11-02 363
interface ILink { /** * 链表增加节点操作 * @param data 节点内容 * @return */ boolean add(Object data); /** * 判断指定内容节点在链表中是否存在 * @param data 要判断的内容 * @return 返回找到的...
深入解析C++的循环链表与双向链表设计的API实现
09-02
总结起来，循环链表和双向链表在C++中是强大的数据结构，它们的API设计需要考虑各种常见的操作，如创建、销毁、插入、删除以及游标管理。理解并能熟练运用这些API对于解决实际问题，尤其是那些涉及到动态数据集合的...
双向链表的设计与实现
qq_33185566的博客
08-23 315
1.双向链表可以完成普通链表的所有操作，并且解决了普通链表逆向遍历效率低的问题。 双向链表相对于普通链表没有多大提示，需要注意的就是插入删除操作时的异常处理， 插入删除0号节点的异常，第一次插入的异常，最后一次删除的异常。 dlinklist.h文件 #pragma once #include "stdio.h" #include "stdlib.h" #include "string....
stm32f103 双向链表
08-16
在这个项目中，我们讨论的是如何在STM32F103上实现一个双向链表的数据结构。双向链表是一种特殊的数据结构，它允许我们在列表中的节点之间进行前向和后向的移动，这在处理动态数据集合时非常有用。 首先，我们要...
双向链表的设计（1）
weixin_44237988的博客
12-10 253
双向链表的设计双向链表节点的定义双向链表的增和删在头结点添加链表元素在尾节点添加元素在链表中间添加元素删除链表中的元素获取索引值index对应的链结点的值获取链表的长度将链表中的元素输出完整代码插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富...
python之数据结构与算法（数据结构篇）-- 队列
2301_81807150的博客
11-05 249
【代码】python之数据结构与算法（数据结构篇）-- 队列。
数据结构[2015]
mufengzhiyu666的博客
11-05 745
八、设有一组关键字{19,01,23,14,55,20,84,27,68,11,10,77},采用哈希函数：H(Key)=Key MOD 13采用开放地址法的二次探测再散列方法解决冲突，试在0～18的散列地址空间中对该关键字序列构造哈希表。七、给出一组关键字(12,2,16,30,28,10,16,20,6,18),分别写出按下列各种排序方法进行排序时的变化过程： (15分)十二、有数组A[4][4],把1到16个整数分别按顺序放入A[0][0],…,A[0][3],A[1][0],…
100种算法【Python版】第49篇——桶排序
AnFany
11-05 137
100种算法【Python版】第49篇——桶排序
数据结构：直接插入排序
versatile_zpc的博客
11-07 201
创建一个end变量让其指向数组中下标为0的元素，也就是第一个元素，再让tmp被赋值为指end+1下标的元素，也就是第二个元素，然后进入while循环，如果tmp < arr[end]，就让end指向的元素走向end+1处，将其覆盖，并且end--，持续遍历，如果end越界了（end<0）,直接跳出，将tmp覆盖掉end+1指向的下标元素，也就是下标为0的元素处。我们将每一张新摸到的牌都插入到自己的牌里，使其形成从大到小的排列。下面我们用代码来实现一下，不同的是将一个乱序的数组排列成一个有序的。
Rust常用数据结构教程 Rust中的数据结构
喜欢打篮球的普通人
11-05 236
复合数据类型Compound types复合类型是通过组合基础类型，用来表达更加复杂的数据结构，即使用其他类型定义的类型，因而复合类型又称之为派生类型。
数据结构初阶排序全解
枫の大一分享
11-03 2084
排序顾名思义，就是将一组乱序的数，按从大到小或者从小到大进行排列的操作。常见的排序如下可以看到排序也是有分类的，既然有分类，那么这边给出宝子们一个思考，在最后测试的时候给出答案，思考1：排序方法这么多，哪个最好呢？最差的有什么用呢？那么废话不多说，今天的重点内容就是理解并写出一个个排序算法，现在直接上高速，带着宝子们攻破一个个排序算法！这边给出各个排序算法的声明，会在对应内容进行解释，宝子们先有个印象即可~~今天讲解了各种类型的排序算法，最常用的还是时间复杂度最小的堆排序、快排、归并排序。
【数据结构-合法括号字符串】【华为笔试题】力扣1190. 反转每对括号间的子串
sjsjs11的博客
11-05 486
让我们来模拟，当遍历s到第一个左括号的时候，他根据pair记录，查找到最外层有括号位置，然后遍历方向改变成向左，这时候遇到i，ret = “i”，然后遍历到内层有括号，索引转换到最内层左括号，方向向右，这时候一一推入’l’,‘o’,‘v’,‘e’，此时ret = “ilove”，然后遇到内层有括号，他根据pair将索引转换到内层左括号，方向向左，然后加入元素’u’，此时ret就是"iloveu"。预处理出括号的对应关系的序列的时间复杂度为 O(n)，遍历字符串的时间复杂度同样为 O(n)。
C语言实现数据结构之堆
最新发布
0xFFFFFFFF
11-08 1168
在这篇文章，我们使用C语言实现了一个物理存储结构为动态顺序表，逻辑结构为二叉树的堆，并实现了堆排序——一种比较快的排序
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值