王道2-9 双向链表插入删除遍历

最新推荐文章于 2023-07-28 22:19:22 发布
最新推荐文章于 2023-07-28 22:19:22 发布
阅读量219 收藏 3
点赞数 1
分类专栏： 数据结构 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cup3380544530/article/details/107918053
版权

目录

1.结构体定义和初始化

init函数:
头结点申请空间(L为空申请失败), 把next prior 设为空

//双向链表的类型定义
typedef struct DLNode{
	int data;
	struct DLNode *prior,*next;
}DLNode,*DLinkList;

//双向链表的初始化
bool InitDLinkList(DLinkList &L){
	L=(DLNode*)malloc(sizeof(DLNode));	//分配一个头结点
	if(L==NULL)
		return false;		//内存分配失败
	L->prior=NULL;			//为空
	L->next=NULL;			//为空
	return true;
}

2.插入

(1).p后插入s ------- p和s不为空
(2).分四步,先连后面后连前面;
(3).注意边界条件,插入到最后位置 即插入的结点的next if(p->next!=NULL)
在这里插入图片描述代码：

//p结点后插入s结点
bool InsertNextNode(DLNode *p,DLNode *s){
	if(p==NULL||s==NULL)		//参数非法
		return false;
	s->next=p->next;  //1
	if(p->next!=NULL)	//插入的那个点->next不为空		
		p->next->prior=s;//2
	s->prior=p;      //3
	p->next=s;      //4
	return true;
	//先写后两个箭头
	//边界插入到最后一个位置if(p->next=NULL)
}

3.删除

(1).删除p后面的q
(2)p q不为空
(3)三步走 先连p— q-----> x ;再连p<---- q ----x ;释放q
(4)删除最后一个结点: 上面需加条件 q->next!=NULL

//删除p的后继结点q
bool DeleteNextDNode(DNode *p){ 
	DNode *q=p->next;
	if(p==NULL)  
	    return false;
	if(q==NULL)  
	    return false;
	q->next=p->next;  //1
	if(q->next!=NULL){ 删除的那个点->next不为空
		q->next->prior=p;  //2
	}
	free(p);		//3
	return true;
//边界:删除最后一个结点 if(q->next=NULL)
}

4.遍历 & 查找(按值 按位)

4.1 双向链表的后向+ 前向遍历

(1)后向遍历: ==while(p!=NULL) { p=p->next; } ==
(2)前向遍历:(包括头结点): ==while(p!=NULL) { p=p->prior; } ==
前向遍历(不包括头结点): ==while(p->prior!=NULL) { p=p->prior; } ==

遍历代码:

void printfDLinkList(DLinkList &L){
	if(L==NULL)
		return ;
	DLNode *p=L->next;
	while(p!=NULL){
		printf("%d\n",p->data);
		p=p->next;//后向遍历
	}
	return;
}

4.2查找代码

==在遍历基础上修改,时间复杂度O(n) ==
按位查找: while(p!=NULL&&j<i)
按值查找: while(p!=NULL&&p->data!=e)

//查找第i元素返回其值---通过遍历实现---O(n)
bool GetElem(DLinkList L,int i,int &e){
	if(i<0)
		return false;
	if(i==0)
		e=L->data;
		return true;
	int j=1;	//j=1开始的长度
	DLNode *p;
	p=L;
	if(p==NULL)
		return false;
	while(p!=NULL&&j<i)//
	{
		p=p->next;
		j++;
			
	}
	e=p->data;
	return true;
}



//双向链表按值查找---通过遍历实现---O(n)
int DLocateElem(DLinkList L,int e){
	int j=1;
	DLNode *p;
	p=L->next;
	while(p!=NULL&&p->data!=e){//
		p=p->next;
				
		j++;
		printf("%d ",j);
	}
	if(p==NULL)
		return 0;
	return (j);
}

5.双向链表完整代码:

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

//双向链表的类型定义
typedef struct DLNode{
	int data;
	struct DLNode *prior,*next;
}DLNode,*DLinkList;


//双向链表的初始化
bool InitDLinkList(DLinkList &L){
	L=(DLNode*)malloc(sizeof(DLNode));	//分配一个头结点
	if(L==NULL)
		return false;		//内存分配失败
	L->prior=NULL;			//为空
	L->next=NULL;			//为空
	return true;
}

//头插法建立双向链表
DLinkList DList_HeadInsert(DLinkList &L){
	int x;
	L=(DLNode*)malloc(sizeof(DLNode));
	if(L==NULL)
		return false;
	L->next=NULL;
	L->prior=NULL;
	scanf("%d",&x);
	while(x!=9999){
		DLNode *s=(DLNode*)malloc(sizeof(DLNode));
		if(s==NULL)
			return false;
		s->data=x;
		s->next=L->next;
		if(L->next!=NULL)
			L->next->prior=s;
		s->prior=L;
		L->next=s;
		scanf("%d",&x);
	}
	return L;
}



//尾插法建立双向链表
DLinkList DList_TailInsert(DLinkList &L){
	int x;
	L=(DLNode*)malloc(sizeof(DLNode));
	L->next=NULL;
	L->prior=NULL;
	scanf("%d",&x);
	DLNode *p;
	p=L;
	while(x!=9999){
		DLNode *s=(DLNode*)malloc(sizeof(DLNode));
		s->data=x;
		p->next=s;
		s->prior=p;
		p=s;
		scanf("%d",&x);
	}
	p->next=NULL;
	return L;
}





//双链表的销毁
void DestoryDList(DLinkList &L)
{
    DLNode *p,*q;
    p=L;
    q=p->next;
    while(q!=NULL){
       	free(p);
        p=q;
        q=p->next;
    }
    free(p);  //释放头结点
}



//双向链表的清空
bool ClearDLinkList(DLinkList &L){
	if(L==NULL)
		return  false;
	DLNode *p;
	p=L->next;
	while(p!=NULL){
		L=p->next;
		if(p->next!=NULL)
			p->next->prior=L;
		free(p);
		p=L->next;
	}
	L->next=NULL;
	return true;
}



//判断带头结点的双链表是否为空
bool Empty(DLinkList L){
    if(L->next==NULL)
        return true;
    else
        return false;
}


//求双向链表的长度
int DLinkListLen(DLinkList L){
	if(L==NULL)
		return false;
	int j=0;
	DLNode *p;
	p=L;
	while(p->next!=NULL){
		p=p->next;
		j++;

	}
	return (j);
}



//查找第i元素返回其值---通过遍历实现---O(n)
bool GetElem(DLinkList L,int i,int &e){
	if(i<0)
		return false;
	if(i==0)
		e=L->data;
		return true;
	int j=1;	//j=1开始的长度
	DLNode *p;
	p=L;
	if(p==NULL)
		return false;
	while(p!=NULL&&j<i)//
	{
		p=p->next;
		j++;
			
	}
	e=p->data;
	return true;
}



//双向链表按值查找---通过遍历实现---O(n)
int DLocateElem(DLinkList L,int e){
	int j=1;
	DLNode *p;
	p=L->next;
	while(p!=NULL&&p->data!=e){//
		p=p->next;
				
		j++;
		printf("%d ",j);
	}
	if(p==NULL)
		return 0;
	return (j);
}



//双向链表的遍历（打印） 后向遍历 前向遍历
/*后向遍历:while(p!=NULL){	p=p->next; } 
前向遍历:while(p!=NULL){	p=p->prior; }
前向遍历(不包括头结点):while(p->prior!=NULL) {p=p->prior; }

  */
void printfDLinkList(DLinkList &L){
	if(L==NULL)
		return ;
	DLNode *p=L->next;
	while(p!=NULL){
		printf("%d\n",p->data);
		p=p->next;//后向遍历
	}
	return;
}



//p结点后插入s结点
bool InsertNextNode(DLNode *p,DLNode *s){
	if(p==NULL||s==NULL)		//参数非法
		return false;
	s->next=p->next;  //1
	if(p->next!=NULL)	//插入的那个点->next不为空		
		p->next->prior=s;//2
	s->prior=p;      //3
	p->next=s;      //4
	return true;
	//先写后两个箭头
	//边界插入到最后一个位置if(p->next=NULL)
}


//删除p的后继结点q
bool DeleteNextDNode(DLNode *p){ 
	DLNode *q=p->next;
	if(p==NULL)   return false;
	if(q==NULL)   return false;
	q->next=p->next;  //1
	if(q->next!=NULL){ 删除的那个点->next不为空
		q->next->prior=p;  //2
	}
	free(p);		//3
	return true;
//边界:删除最后一个结点 if(q->next=NULL)
}


void main(){
	DLinkList L,s;
	InitDLinkList(L);
	DList_TailInsert(L);
	int a= DLinkListLen(L);
	printf("双向链表的长度为=%d\n",a);
	printfDLinkList(L);

	 printf("位序为：%d\n",DLocateElem(L,5));
	 int e;
	 if(GetElem(L,2,e)==1)
		printf("yes\n");
	 else 
		 printf("no found");

}
黑糖儿*
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
---:链表创建与遍历的算法
04-22
--- 链表创建与遍历的算法 可
双向链表的插入和删除
m0_73442004的博客
03-17 1984
然后让所需删除节点的前一结点的后继指向所需删除的节点的后一节点。再让后一节点的前驱找到删除节点的前一节点。单链表是单向的，有一个头结点，一个尾结点，要访问任何结点，都必须知道头结点，不能逆着进行。而双链表添加了一个指针域，通过两个指针域，分别指向结点的前结点和后结点。这样的话，可以通过双链表的任何结点，访问到它的前结点和后结点。如果插入的不是第一个节点：让新节点的后继指向前节点的后继。旧节点的下一节点的前驱指向新节点。上一节点的后继指向新节点。让头结点的next指向新节点，新节点的前驱指向头节点。
双向链表的删除和插入
热门推荐
m0_61395860的博客
02-05 1万+
一、初始操作 双向链表定义如下： #include<stdio.h> #include<stdlib.h> typedef struct DLnode{ int data; struct DLnode *prev,*next; }DLnode,*DLinklist; 尾插法创建： void Create(DLinklist &L){ L=(DLinklist)malloc(sizeof(DLnode)); L->next=NULL; D
【链表】双向链表的插入与删除
lxylxylxy的博客
11-05 1772
双向链表的插入和删除操作
双链表的插入与删除
最新发布
qq_65761686的博客
07-28 1215
在插入操作中，我们首先将新节点的prev指针指向前一个节点，next指针指向前一个节点的后继节点。在删除操作中，我们首先判断待删除节点的前一个节点和后一个节点是否存在，然后更新它们的指针，将待删除节点从链表中移除。双链表（Doubly Linked List）是一种链表数据结构，它与单链表相比，在每个节点上都有两个指针，一个指向前一个节点，一个指向后一个节点。在双链表中插入一个节点，需要先找到插入位置的前一个节点，然后通过更新指针的方式将新节点插入到前一个节点和后一个节点之间。
双向链表实现简单的增删查改
weixin_72868952的博客
01-29 1598
双向带头循环链表——用最复杂的结构完成最简单的工作
java代码-笔试代码提交 -----链表遍历找出表头
07-16
java代码-笔试代码提交 -----链表遍历找出表头
双向链表插入删除基本应用介绍
09-05
本文将详细介绍建立双向链表,实现对双向链表的插入,删除操作，需要了解的朋友可以参考下
双向链表的创建和基本操作（增，删，改，查）
m0_67186846的博客
08-20 425
双向链表的创建和基本操作（增，删，改，查）
双向链表遍历以及增删改查操作(思路分析) [数据结构][Java]
m0_57001006的博客
08-22 217
我们要增加,那么就要先找到双向链表中的最后一个结点,我们用一个临时变量temp记录这个最后的结点先让我们的temp的next指向新的结点: temp.next = newHeroNode;然后让新的结点的pre指向temp : newHeroNode.pre = temp;
双向链表创建插入删除销毁等
11-29
双向链表，创建，插入，删除，销毁等，写的一个代码（包括详细的注释，初学者都看得懂），已经成功测试。及拿即用。
删除循环双向链表中指定元素
11-05
本小程序是对于循环双向链表中删除指定元素 考虑几种边界情况!
链表、双链表的插入和删除
axbhealj的博客
03-27 1273
链表、双链表插入和删除、什么是头结点和头指针？、头结点和头指针有什么用
【数据结构】链表：带头双向循环链表的增删查改
wangduduniubi的博客
05-16 969
本篇要分享的内容是带头双向链表在刚开始接触链表的时候，我们所学仅仅所学的是单链表，相信大家用C语言学习单链表时也倍受二级指针的折磨。当然单链表只是链表结构内的一种，他的结构非常简单，但是理解并操作起来却非常困难；而我们今天要研究的是链表中结构最复杂，但是理解起来最简单的链表的结构。
双向链表的插入和删除的实现
Nactua的博客
05-02 5365
双向链表的操作实现包括：初始化指针，打印链表，插入链表以及删除链表。 1、初始化结构体 实现的代码如下： #include <stdio.h> #include <malloc.h> //初始化结构体，一个是前驱指针，一个后继指针. typedef struct DoubleLinkedNode{ char data; struct DoubleLinkedNode *previous; struct DoubleLinkedNode *next; } DLNo
王道2-2-24
qq_42186444的博客
07-01 394
题目大意 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。 说明：不允许修改给定的链表。 。 思路 快慢两个指针，fast走两步，slow走一步，如果相遇就是有环 假设head与入幻点相差a，入环与slow差b，fast比slow多走a+b（2倍关系），若slow再走a会到入幻点（因为入幻与slow差b），而且head走a也是入幻点
王道2-2-25
qq_42186444的博客
07-01 155
题目大意 给定一个单链表 L：L0→L1→…→Ln-1→Ln ， 将其重新排列后变为： L0→Ln→L1→Ln-1→L2→Ln-2→… 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 思路 先找到中间节点，q用两次next，p用一次next，等q为空，那么p就是中间节点 对p后面的节点进行头插法，形成逆序，如123456，变成123465，*注意是465* 然后进行断链，形成1234和65两条链 最后进行和链162534 代码实现 void reorderList(ListNod
王道2-2-6
qq_42186444的博客
07-01 411
题目大意 给定一个头结点链表，按照从小到大排序 思路 根据插入排序的思路和逆置链表的思路，首先先把头结点和他的next摘出p，让p为读取元链表的节点，pre为摘出来新链表的头结点，然后pre遍历，小于p.val的就继续，不然就是正常的插入。 代码实现 struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; //本题思路插入排序，头插法类似，吧l取出，做个
双向链表，添加，删除一个节点
wuyiyu_的博客
12-29 3355
链表有几种，大致分为：单链表， 双向链表，循环链表，静态链表。这里为大家简单介绍双向链表节点的添加，删除。提示：以下是本篇文章正文内容，下面案例可供参考双向指针并不难，大家要多加理解。
#include <stdio.h>#include <string.h>void help(void){ printf("****************************\n"); printf("*help:帮助信息 *\n"); printf("*insert:插入链表节点 *\n"); printf("*print:遍历链表节点 *\n"); printf("*search:查询链表某个节点 *\n"); printf("*delet:删除链表某个节点 *\n"); printf("*free:释放整个链表 *\n"); printf("*quit:退出程序 *\n"); printf("****************************\n");}int main(int argc,char const *argv[]){ help(); while(1); { char cmd[128] =""; printf("请输入操作命令:"); scanf("%s",cmd); if(strcmp(cmd,"help") == 0) { help(); } else if(strcmp(cmd,"insert") == 0) { printf("-------链表插入-------\n"); } else if(strcmp(cmd,"print") == 0) { printf("-------链表遍历-------\n"); } else if(strcmp(cmd,"search") == 0) { printf("-------链表查询-------\n"); } else if(strcmp(cmd,"delet") == 0) { printf("-------链表删除-------\n"); } else if(strcmp(cmd,"free") == 0) { printf("-------链表释放-------\n"); } else if(strcmp(cmd,"quit") == 0) { break; } } return 0;}
06-08
printf("-------链表删除-------\n"); } else if(strcmp(cmd,"free") == 0){ printf("-------链表释放-------\n"); } else if(strcmp(cmd,"quit") == 0){ break; } } return 0; } ``` 另外，建议在scanf...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值