双向链表按位置删除、修改、查找&&双向循环链表输出、头插、头删、尾插尾删

最新推荐文章于 2023-09-02 15:40:18 发布
最新推荐文章于 2023-09-02 15:40:18 发布
阅读量201 收藏
点赞数
文章标签： c语言 算法 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60026178/article/details/130754059
版权
该代码实现了一个双向链表的数据结构，包括头插法、头删除、尾插入、尾删除以及按位置插入、删除、修改和查找功能。程序首先创建链表，然后允许用户输入数据进行各种操作，最后输出链表内容。循环链表部分则实现了头插、头删、尾插和尾删功能。
摘要由CSDN通过智能技术生成

双向列表：

#include"head2.h"

int main(int argc, const char *argv[])
{
	double_linklist L=create(1);

	//循环头插
	int n;
	datatype e;
	printf("输入插入个数:");
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		printf("输入%d数据元素:",i+1);
		scanf(" %c",&e);
		insert_head(L,e);
	}
	output(L);

	//头删
//	delete_head(L);
//	delete_head(L);

//	delete_rear(L);
//	delete_rear(L);
/*
	int pos;
	datatype e;
	printf("输入插入的位置:");
	scanf("%d",&pos);
	printf("输入插入的值:");
	scanf(" %c",&e);
	insert_pos(L,pos,e);
	output(L);
*/
/*按位置删除
	int pos;
	printf("输入删除的位置:");
	scanf("%d",&pos);
	delete_pos(L,pos);
	output(L);
*/
/*按位置修改
	int pos;
	printf("输入修改的位置:");
	scanf("%d",&pos);
	printf("输入修改的值:");
	scanf(" %c",&e);
	change_pos(L,pos,e);
	output(L);
*/
/*按位置查找
	int pos;
	printf("输入查找的位置:");
	scanf("%d",&pos);
	find_pos(L,pos);
*/
	


	return 0;
}
#include"head2.h"
/*
 * function:    创建头节点
 * @param [ in] 
 * @param [out] 无
 * @return      成功返回地址 失败返回NULL
 */
double_linklist create(int flag)
{
	double_linklist L=(double_linklist)malloc(sizeof(struct Node));
	if(L==NULL)
	{
		return NULL;
	}
	if(flag==1)
	{
		L->len=0;
	}
	else if(flag==0)
	{
		L->data=0;
	}
	L->next=NULL;
	L->prev=NULL;
	return L;
}

/*
 * function:    
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int insert_head(double_linklist L,datatype e)
{
	if(L==NULL)
	{
		return -1;
	}
	double_linklist s=create(0);
	if(s==NULL)
	{
		return -1;
	}
	s->data=e;
	//指针域
	s->next=L->next;
	s->prev=L;
	if(L->next!=NULL)
	{
		L->next->prev=s;
	}
	L->next=s;
	L->len++; 
	return 0;

}

/*
 * function:    循环输出
 * @param [ in] 链表
 * @param [out] 
 * @return      无
 */
void output(double_linklist L)
{
	if(L==NULL||L->next==NULL)
	{
		printf("遍历失败\n");
		return;
	}
	puts("正向遍历");
	double_linklist p=L;
	while(p->next!=NULL)
	{
		p=p->next;
		printf("%c\t",p->data);
	}
	puts("\n逆向遍历");
	while(p->prev!=NULL)
	{
		printf("%c\t",p->data);
		p=p->prev;
	}
	puts("");
}
/*
 * function:    尾部插入
 * @param [ in] 链表 插入的值
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int insert_rear(double_linklist L,datatype e)
{
	if(L==NULL)
	{
		return -1;
	}
	//循环到尾节点
	double_linklist p=L;
	while(p->next!=NULL)
	{
		p=p->next;
	}
	double_linklist s=create(0);
	if(s==NULL)
	{
		return -1;
	}
	s->data=e;
	s->prev=p;
	p->next=s;
	L->len++;
	return 0;
}
/*
 * function:    头删除
 * @param [ in] 
 * @param [out] 链表
 * @return      成功返回0 失败返回-1
 */
int delete_head(double_linklist L)
{
	if(L==NULL||L->next==NULL)
	{
		return -1;
	}
	double_linklist p=L->next;
	L->next=p->next;
	if(p->next!=NULL)
	{
		p->next->prev=L;
	}
	free(p);
	p=NULL;
	L->len--;
}
/*
 * function:    尾部删除
 * @param [ in] 链表
 * @param [out] 
 * @return      成功返回0 失败返回-1
 */
int delete_rear(double_linklist L)
{
	if(L=NULL)
	{
		return -1;
	}
	double_linklist p=L;
	while(p->next!=NULL)
	{
		p=p->next;
	}
	p->prev->next=NULL;
	free(p);
	p=NULL;
	L->len--;
	return 0;
}
/*
 * function:    按位置插入
 * @param [ in] 
 * @param [out] 
 * @return      
 */
int insert_pos(double_linklist L,int pos,datatype e)
{
	if(L==NULL||pos<1||pos>L->len+1)
	{
		printf("插入失败");
		return -1;
	}
	double_linklist p=L;
	for(int i=0;i<pos-1;i++)
	{
		p=p->next;
	}
	double_linklist s=create(0);
	if(s==NULL)
	{
		return -1;
	}
	s->data=e;
	s->next=p->next;
	s->prev=p;
	if(p->next!=NULL)
	{
		p->next->prev=s;
	}
	p->next=s;
	L->len++;
	return 0;
}

//按位置删除
int delete_pos(double_linklist L,int pos)
{
	if(L==NULL||pos<1||pos>L->len)
	{
		printf("插入失败");
		return -1;
	}
	double_linklist p=L;
	for(int i=0;i<pos-1;i++)
	{
		p=p->next;
	}
	double_linklist q=p->next;
	p->next=q->next;
	if(q->next!=NULL)
	{
		q->next->prev=p;
	}
	free(q);
	q=NULL;
	L->len--;
	return 0;
}

//按位置修改
int change_pos(double_linklist L,int pos,datatype e)
{
	if(L==NULL||pos<1||pos>L->len)
	{
		printf("插入失败");
		return -1;
	}
	double_linklist p=L;
	for(int i=0;i<pos-1;i++)
	{
		p=p->next;
	}
	p->data=e;
	return 0;
}

//按位置查找
int find_pos(double_linklist L,int pos)
{
	if(L==NULL||pos<1||pos>L->len)
	{
		printf("插入失败");
		return -1;
	}
	double_linklist p=L;
	for(int i=0;i<pos;i++)
	{
		p=p->next;
	}
	printf("查找的第%d位为: %c\n",pos,p->data);
}
#ifndef  __HEAD_H__

#define  __HEAD_H__

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedef char datatype;
typedef struct Node
{
	union{
		int len;
		datatype data;
	};
	struct Node *next;
	struct Node *prev;
}*double_linklist;

double_linklist create(int flag);
int insert_head(double_linklist L,datatype e);
void output(double_linklist L);
int delete_head(double_linklist L);
int delete_rear(double_linklist L);

int delete_pos(double_linklist L,int pos);
int change_pos(double_linklist L,int pos,datatype e);
int find_pos(double_linklist L,int pos);

#endif

1、双向链表按位置删除

 2、双向链表按位置修改

 3、双向链表按位置查找

 双向循环链表：

#ifndef  __HEAD_H__

#define  __HEAD_H__

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

typedef float datatype;
typedef struct Node
{
	union{
		int len;
		datatype data;
	};
	struct Node *next;
	struct Node *prev;
}*loop_double_link;


loop_double_link create(int flag);
int insert_head(loop_double_link L,datatype e);
void output(loop_double_link L);
int delete_head(loop_double_link L);
int insert_rear(loop_double_link L,datatype e);
int delete_rear(loop_double_link L);



#endif

 

#include"head3.h"
int main(int argc, const char *argv[])
{
	loop_double_link L=create(1);
//	头插
/*
 	int n;
	datatype e;
	printf("输入个数:");
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		printf("输入第%d个插入的元素:",i+1);
		scanf("%f",&e);
		insert_head(L,e);
	}
	output(L);
*/
/*头删
	delete_head(L);
	output(L);
*/
//尾插
//
	int n;
	datatype e;
	printf("输入个数:");
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		printf("输入第%d个插入的元素:",i+1);
		scanf("%f",&e);
		insert_rear(L,e);
	}
	output(L);
//
/*尾删
	delete_rear(L);
	output(L);
*/
	return 0;
}
#include"head3.h"
/*
 * function:    创建节点
 * @param [ in] 
 * @param [out] 1:头 0:普通
 * @return      成功返回地址  失败返回null
 */
loop_double_link create(int flag)
{
	loop_double_link L=(loop_double_link)malloc(sizeof(struct Node));
	if(L==NULL)
	{
		return NULL;
	}
	if(flag==1)
	{
		L->len=0;
		L->next=L;
		L->prev=L;
	}
	else if(flag==0)
	{
		L->len=0;
		L->next=NULL;
		L->prev=NULL;
	}
	return L;
}
/*
 * function:    头插
 * @param [ in] 链表 插入的值
 * @param [out] 
 * @return      成功返回0  失败返回-1
 */
int insert_head(loop_double_link L,datatype e)
{
	if(L==NULL)
	{
		return -1;
	}
	loop_double_link s=create(0);
	if(s==NULL)
	{
		return -1;
	}
	s->data=e;
	s->next=L->next;
	s->prev=L;
	L->next->prev=s;
	L->next=s;
	L->len++;
	return 0;
}
void output(loop_double_link L)
{
	puts("正向遍历");
	loop_double_link p=L;
	while(p->next!=L)
	{
		p=p->next;
		printf("%.1f\t",p->data);
	}
	puts("\n逆向遍历");
	while(p->prev!=L->prev)
	{
		printf("%.1f\t",p->data);
		p=p->prev;
	}
	printf("\n");
}
//头删
int delete_head(loop_double_link L)
{
	if(L==NULL)
	{
		return -1;
	}
	loop_double_link p=L->next;
	L->next=p->next;
	p->next->prev=L;
	free(p);
	p=NULL;
	return 0;
}
//尾插
int insert_rear(loop_double_link L,datatype e)
{
	if(L==NULL)
	{
		return -1;
	}
	loop_double_link s=create(0);
	if(s==NULL)
	{
		return -1;
	}
	loop_double_link p=L->prev;
	s->data=e;
	s->next=p->next;
	s->prev=p;
	p->next->prev=s;
	p->next=s;
	L->len++;
	return 0;
}
//尾删
int delete_rear(loop_double_link L)
{
	if(L==NULL)
	{
		return -1;
	}
	loop_double_link p=L->prev;
	p->prev->next=L;
	L->prev=p->prev;
	free(p);
	p=NULL;
	return 0;
}

1、双向链表循环链表头插

 2、双向链表循环链表头删

 3、双向链表循环链表尾插

4、双向链表循环链表尾删

 

我没说你可以肘了
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
双向链表的插入、删除、查找
04-02
这是一个关于双向链表的建立、头部插入、尾部插入、查找元素、删除元素的完整程序。
头插法、尾插法、链表长度test-c-master.zip
最新发布
04-17
在这个“头插法、尾插法、链表长度test_c-master.zip”压缩包中，我们可以推测包含的是关于链表操作的C语言实现，主要涉及了链表的头插法和尾插法以及如何计算链表的长度。 首先，让我们详细探讨一下链表中的头插法...
数据结构之双向链表
小武的Blog
06-03 159
1.双向链表 1.1双向链表创建示意图 1559566817318.png 分析 双向链表的遍历，添加，修改，删除的操作思路===》代码实现： 遍历 方和 单链表一样，只是可以向前，也可以向后查找 添加 (默认添加到双向链表的最后) (1) 先找到双向链表的最后这个节点 (2) temp.next = newHeroNode (3...
双向链表的查找 c语言,双向链表的查找 -- C语言
weixin_39851918的博客
05-21 199
代码实现st_doubNode* searchDoubListNode(st_doubNode* head, int num){if(NULL == head){return NULL;}st_doubNode* p = NULL;st_doubNode* q = NULL;p = head;while(NULL != p){if(p->data == num){q = p;break;}p...
双向链表的查找 c语言,C语言查找双向链表中数据项程序
weixin_35828992的博客
05-21 241
创建一个双向链表，并查找此双向链表中的数据项的示例程序，将以下代码保存到一个源文件中：search_doubly_linked_list.c， 如下所示 –#include #include struct node { int data; struct node *prev; struct node *next; }; struct node *h...
双向链表按位置查找 -- C语言
六六哥的博客
02-18 227
代码实现 st_doubNode * findDoubListPos(st_doubNode * head, int pos){ if(NULL == head || pos < 0){ return NULL; } if(0 == pos) { return head; } st_doubNode * p = NULL; st_doubNode * q = NU...
test3-插入.rar_尾插法_有头插法_链表 插入创建
09-20
当链表较大时，尾插法可能比有头插法效率稍低，因为需要遍历整个链表来找到尾部。 在学习链表插入操作时，理解这两种方法的实现至关重要。这不仅有助于提升编程技能，也是准备面试或解决实际问题的基础。资料包中的...
sss.rar_sss_双向链表_链表_链表 插入
09-14
插入节点操作分为头插、尾插以及在任意位置插入。在双向链表中，插入节点时需要同时更新前后两个节点的指针。例如，在某个节点后插入新节点，需要将新节点的前一个指针设为原节点，后一个指针设为原节点的后一个节点...
C语言数据结构之双向循环链表的实例
08-30
我们可以使用头插法和尾插法来实现链表的插入和删除操作。 在链表的实现中，我们需要注意链表的边界情况，例如链表为空时的处理、链表的头结点和尾结点的处理等。同时，我们也需要注意链表的内存分配和释放，以避免...
04_双向链表_链表_declaredzfw_双向链表_
10-01
本文将深入探讨双向链表的概念及其在实际编程中的应用，以标题"04_双向链表_链表_declaredzfw_双向链表_"所提及的源码为例，结合"链表 declaredzfw 双向链表"的标签进行详细讲解。 双向链表（Doubly Linked List）...
双向循环链表C++
Worthwhile_DUT的博客
11-23 1409
双向循环链表是在循环链表（不定义头指针，而是定义尾指针）的基础上，增加一个指针域，注意头节点的前驱是指向最后一个元素，链表中存在两个环。
循环双向链表（C++）
weixin_53088153的博客
09-02 186
的循环双向链表c++实现。
数据结构——双向链表
m0_70184760的博客
07-29 1345
数据结构——双向链表
C++数据结构学习——双向循环链表
qq_40231851的博客
08-22 276
*双向链接：**每个节点都包含两个指针，一个指向前一个节点（前驱节点），另一个指向后一个节点（后继节点）。这种双向连接使得在链表中可以轻松地在两个方向上遍历节点。**循环性质：**最后一个节点的后继节点指向第一个节点，形成一个环状结构。这意味着可以无限循环遍历链表，因为没有真正的末尾。**灵活性：**由于双向链接，可以方便地在链表中插入、删除和移动节点，而不需要像单链表那样需要迭代查找前一个节点。**前向和后向遍历：**可以从任何节点开始，向前或向后遍历整个链表。
数据结构与算法——双向链表
三横同学的博客
04-23 528
双向链表 使用带head头的双向链表实现-水浒英雄排行榜管理单向链表的缺点分析: 1)单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。 2)单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除，所以前面我们单链表删除时节点，总是找到temp,temp是待删除节点的前一个节点(认真体会). 3)示意图帮助理解删除 实现思路： 分析双向链表的遍历，添加，修改，删除的操作思路===》代码实现 1)遍历方式和单链表一样，只是可以向前，也可以向后查找 2)添加(默认添加到双向链表的最
线性表之双向链表的建立、查找、插入和删除（附C++程序）
ch18328071580的博客
07-07 3686
本文详细介绍了数据结构的双链表的定义，以及双向链表的建立、查找、插入和删除
学习C/C++语言系列（1）双向循环带哨兵位链表
roseisbule的博客
03-24 2481
虽然双向循环比单链表和循序表结构要复杂，但在我目前看来，它比单链表，顺序表都要好用，都更实用。所以我想在单链表和顺序表之前先讲解一下我学到的双向循环带哨兵位链表。 首先来讲一讲什么是哨兵位。 如图，哨兵位其实是一个在头节点之前的节点，这个节点并不存放有效值，只存放头节点的地址和尾节点的地址。 哨兵位 为什么要有哨兵位呢？ 1.对于一个已经创建和初始化的链表来讲，可以没有数据，即头节点，尾节点等，但是不能没有哨兵位，...
双向循环链表的头插尾插中间插基本操作
qq_26654257的博客
09-29 1985
以前一致一直用单向链表，而且对链表的理解模模糊糊，经过一段时间的理解刷题，略微懂了链表的操作，下面贴一下我不借助任何书自己通过草稿想出来的双向循环聊表链表基本操作 #include #include struct Test { #include #include struct Test { int num; struct Test *prior; struct Tes
数据结构与算法——双向链表基本操作（C语言实现）
Itmastergo的博客
07-20 406
前面学习了如何创建一个双向链表，下面学习有关双向链表的一些基本操作，即如何在双向链表中添加、删除、查找或更改数据元素。
双向循环链表有头插法尾插法吗
05-22
双向循环链表同样可以使用头插法和尾插法进行插入操作。 使用头插法时，新节点插入在链表头部，需要进行以下操作： 1. 创建新节点； 2. 将新节点的next指针指向原来的头节点； 3. 将新节点的prev指针指向原来的头节点的上一个节点； 4. 将原来的头节点的prev指针指向新节点； 5. 将链表的头节点指向新节点。 使用尾插法时，新节点插入在链表尾部，需要进行以下操作： 1. 创建新节点； 2. 将新节点的prev指针指向原来的尾节点； 3. 将新节点的next指针指向原来的尾节点的下一个节点（即头节点）； 4. 将原来的尾节点的next指针指向新节点； 5. 将链表的尾节点指向新节点。 需要注意的是，双向循环链表的头节点和尾节点是相互指向的，因此在进行插入操作时需要特别处理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值