不带头结点的双链表 和 带头结点的双链表

已于 2024-05-11 10:11:53 修改
阅读量204 收藏 5
点赞数 5
文章标签： c++ 数据结构 链表
于 2024-04-22 21:00:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_70744989/article/details/138088871
版权

目录

双链表的定义（两种都一样）

不带头结点的双链表 

初始化

头插操作（为链表赋值）

插入操作（后插操作）

前插操作（由于有前驱结点，所以可以直接前插，不需要写这么复杂）

删除操作（删除当前结点）

查找第i个结点

总结

完整代码

带头结点的双链表 

初始化

头插操作（为链表赋值）

前插操作，后插操作，删除操作

查找第i个结点

完整代码

总结

今天复习双链表，以前复习的时候只看了带头结点的，今天居然发现不带头结点的不会写

双链表的定义（两种都一样）

typedef struct DNode
{
	int data;
	struct DNode *prior,*next;
}DNode,*DLinkList;

不带头结点的双链表 

初始化

由于不带头结点，所以初始化只有头指针

bool InitList(DLinkList &L)
{
	L=NULL;
	return true;
}
头插操作（为链表赋值）

指的是在头指针所指结点之前插入元素（带头结点是在头结点之后插入）

当链表为空时，插入第一个节点需要特判，因为插入的结点的后继结点为空

void InsertList(DLinkList &L,int x) //头插：在头指针所指结点之前插入元素 
{
	DNode *p=new DNode;
	p->data=x;
	if(L==NULL)  //特殊处理第一个节点 
	{
		p->next=NULL;
		p->prior=L;
		L=p;
		//L=p;
        //p->next=NULL;
        //p->prior=NULL;
	}
	else
	{
	    p->next=L;
	    L->prior=p;
	    p->prior=NULL;    //插入的为首元素，prior指针指向NULL
	    L=p;              
	} 
}

一直头插就可以将数据逆序读入

插入操作（后插操作）
bool InsertAfterNode(DNode *p,int x)  //在p结点之后插入元素，值为x 
{
	DNode *q=new DNode;
	if(q==NULL) return false; 
	q->data=x;
	q->next=p->next;
	p->next->prior=q;
	q->prior=p;
	p->next=q;
	return true;
}
前插操作（由于有前驱结点，所以可以直接前插，不需要写这么复杂）

单链表由于只有后继结点，方便实现后插，但不方便前插，所以单链表要想实现前插，才需要写这么复杂

bool InsertBehindNode(DNode *p,int x)  //在p结点之前插入元素，值为x 
{
	DNode *q=new DNode;
	if(q==NULL) return false; 
	q->data=p->data;
	p->data=x;   //依旧是后插，只是将插入结点的值赋为前结点p的值，p的值为插入元素的值 
	q->next=p->next;
	p->next->prior=q;
	q->prior=p;
	p->next=q;
	return true;
}
删除操作（删除当前结点）
bool Delete(DNode *p)  //删除p结点 
{
	p->prior->next=p->next;
	delete p;
}
查找第i个结点
DNode* Find(DLinkList L,int i)  //查找第i个结点 
{
	int j=1;
	DNode *p=L;
	while(p!=NULL&&j<i)
	{
		p=p->next;
		j++; 
	}
	return p;
}
总结

主要是头插法插入的位置头指针所指元素之前，进而让头指针指向新插入的结点，而不是头指针之后（话术有问题），更不是头结点之后

完整代码
#include<bits/stdc++.h>
#define int long long

using namespace std;

int n;

typedef struct DNode
{
	int data;
	struct DNode *prior,*next;
}DNode,*DLinkList;

bool InitList(DLinkList &L)
{
	L=NULL;
	return true;
}

void InsertList(DLinkList &L,int x) //头插：在头指针所指节点之前插入元素 
{
	DNode *p=new DNode;
	p->data=x;
	if(L==NULL)  //特殊处理第一个节点 
	{
//		p->next=NULL;
//		p->prior=L;
//		L=p;
		L=p;
        p->next=NULL;
        p->prior=NULL;
	}
	else
	{
	    p->next=L;
	    L->prior=p;
	    p->prior=NULL;
	    L=p;
	} 
}

DNode* Find(DLinkList L,int i)  //查找第i个结点 
{
	int j=1;
	DNode *p=L;
	while(p!=NULL&&j<i)
	{
		p=p->next;
		j++; 
	}
	return p;
} 

bool InsertAfterNode(DNode *p,int x)  //在p结点之后插入元素，值为x 
{
	DNode *q=new DNode;
	if(q==NULL) return false; 
	q->data=x;
	q->next=p->next;
	p->next->prior=q;
	q->prior=p;
	p->next=q;
	return true;
}

bool InsertBehindNode(DNode *p,int x)  //在p结点之前插入元素，值为x 
{
	DNode *q=new DNode;
	if(q==NULL) return false; 
	q->data=p->data;
	p->data=x;   //依旧是后插，只是将插入结点的值赋为前结点p的值，p的值为插入元素的值 
	q->next=p->next;
	p->next->prior=q;
	q->prior=p;
	p->next=q;
	return true;
}

bool Delete(DNode *p)  //删除p结点 
{
	p->prior->next=p->next;
	delete p;
}

void PrintList(DLinkList L)
{
	DNode *p=L;
	while(p!=NULL)
	{
		cout<<p->data<<" ";
		p=p->next;
	}
	cout<<endl;
}

signed main()
{
	freopen("A.txt","r",stdin);
	cin>>n;
	
	DLinkList L;
	InitList(L);
	
	while(n--)
	{
		int x; cin>>x;
		InsertList(L,x);
	}
	
	PrintList(L);
	
	DNode *p=Find(L,3);
	
	InsertAfterNode(p,5);
	
	PrintList(L);
	
	InsertBehindNode(p,5);
	
	PrintList(L);
	
	Delete(p);
	
	PrintList(L);
	return 0;
}

带头结点的双链表 

初始化
bool InitList(DLinkList &L)
{
	L=new DNode;               //创建头指针
	if(L==NULL) return false;   
	L->next=NULL;    //头指针前驱和后继要置为NULL，区别于不带头结点的双链表
	L->prior=NULL;
	return true;
}
头插操作（为链表赋值）
void InsertList(DLinkList &L,int x) //头插：在头指针所指节点之前插入元素 
{
	DNode *p=new DNode;
	p->data=x;
	if(L->next==NULL)  //特殊处理第一个节点 
	{
		p->next=NULL;
		p->prior=L->next;
		L->next=p;
	}
	else
	{
	    p->next=L->next;
	    L->next->prior=p;
	    p->prior=L->next;
	    L->next=p;
	} 
}
前插操作，后插操作，删除操作

和前面一样

查找第i个结点
DNode* Find(DLinkList L,int i)  //查找第i个结点 
{
	int j=1;
	DNode *p=L->next;
	while(p!=NULL&&j<i)
	{
		p=p->next;
		j++; 
	}
	return p;
}
完整代码
#include<bits/stdc++.h>
#define int long long

using namespace std;

int n;

typedef struct DNode
{
	int data;
	struct DNode *prior,*next;
}DNode,*DLinkList;

bool InitList(DLinkList &L)
{
	L=new DNode;
	if(L==NULL) return false;
	L->next=NULL;
	L->prior=NULL;
	return true;
}

void InsertList(DLinkList &L,int x) //头插：在头指针所指节点之前插入元素 
{
	DNode *p=new DNode;
	p->data=x;
	if(L->next==NULL)  //特殊处理第一个节点 
	{
		p->next=NULL;
		p->prior=L->next;
		L->next=p;
	}
	else
	{
	    p->next=L->next;
	    L->next->prior=p;
	    p->prior=L->next;
	    L->next=p;              //相当于是插入一个 
	} 
}

DNode* Find(DLinkList L,int i)  //查找第i个结点 
{
	int j=1;
	DNode *p=L->next;
	while(p!=NULL&&j<i)
	{
		p=p->next;
		j++; 
	}
	return p;
} 

bool InsertAfterNode(DNode *p,int x)  //在p结点之后插入元素，值为x 
{
	DNode *q=new DNode;
	if(q==NULL) return false; 
	q->data=x;
	q->next=p->next;
	p->next->prior=q;
	q->prior=p;
	p->next=q;
	return true;
}

bool InsertBehindNode(DNode *p,int x)  //在p结点之前插入元素，值为x 
{
	DNode *q=new DNode;
	if(q==NULL) return false; 
	q->data=p->data;
	p->data=x;   //依旧是后插，只是将插入结点的值赋为前结点p的值，p的值为插入元素的值 
	q->next=p->next;
	p->next->prior=q;
	q->prior=p;
	p->next=q;
	return true;
}

bool Delete(DNode *p)  //删除p结点 
{
	p->prior->next=p->next;
	delete p;
}

void PrintList(DLinkList L)
{
	DNode *p=L->next;
	while(p!=NULL)
	{
		cout<<p->data<<" ";
		p=p->next;
	}
	cout<<endl;
}

signed main()
{
	freopen("A.txt","r",stdin);
	cin>>n;
	
	DLinkList L;
	InitList(L);
	
	while(n--)
	{
		int x; cin>>x;
		InsertList(L,x);
	}
	
	PrintList(L);
	
	DNode *p=Find(L,3);
	
	InsertAfterNode(p,5);
	
	PrintList(L);
	
	InsertBehindNode(p,5);
	
	PrintList(L);
	
	Delete(p);
	
	PrintList(L);
	return 0;
}

总结

还是要多做总结，to be modest

1001 0110
关注
  • 5
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
链表——不带头结点
Yolanda_Vamper的博客
09-12 261
创建不带头结点单链表 设计递归算法，删除单链表L中所有值为x的结点 #include<bits/stdc++.h> using namespace std; typedef struct LNode{ int data; struct LNode *next; }LNode, *LinkList; //不带头结点创建单链表 LinkList CreateLis...
带头结点的双向循环链表
07-17
总结来说，带头结点的双向循环链表是一种灵活且实用的数据结构，它在C++中的实现涉及节点定义、链表操作的实现以及封装为类。理解并掌握这一数据结构对于提升编程能力，尤其是处理复杂算法问题具有重要意义。
双链表（不带头结点）
s_ai_yan的博客
03-06 383
使用 `DList_Show` 和 `DList_Show_Back` 函数，分别从头到尾和从尾到头打印链表的所有结点的值。- 使用 `DList_Get_Elem` 函数，通过给定的值在链表中查找结点，同时返回结点所在的位序。4. **创建双链表（头插法，不带头节点）：**8. **打印链表所有值（正序和倒序）：**3. **获取链表有效数据节点个数：**6. **通过值获取结点和位序：**1. **初始化链表：**5. **按位序插入：**7. **按位序删除：**9. **主函数：**
数据结构之双链表（不带头节点的插入删除打印）
浪迹天涯的专栏
03-27 572
#include #include #include typedef int DataType; typedef struct DLinkNode { DataType data; struct DLinkNode *prior; struct DLinkNode *rear; }DLinkNode,*DLinkList; // 不带头节点的双链表 int CreatDLinkL
线性链表（不带头结点）
yezeen的博客
08-01 710
目录 一、基本操作实现 1.单链表存储结构 2. 函数声明 3. 基本操作函数定义（与带头结点实现有差别的操作） (1)创建 (2)销毁&清空 (3)插入元素 (4)删除元素 二、基本操作函数测试 三、 全部代码 四、总结 一、基本操作实现 1.单链表存储结构 //线性链表_不带头结点 #include<stdio.h> #include<stdlib.h> //线性表的单链表存储结构 typedef struct LNode { int
【不带头节点的单链表】
98同学吖的博客
04-23 2574
不带头节点的单链表
带头结点双链循环线性表.rar_循环双链表
09-14
在“带头结点双链循环线性表”中，“头结点”是一个特殊的结点，它的存在主要是为了方便对链表进行操作，例如插入和删除元素。头结点不存储实际的数据，而是作为链表的起点，连接着链表中的第一个元素。同时，由于是...
链表-使用C语言实现非循环双向链表-带头结点+尾结点.zip
最新发布
03-13
本篇将详细介绍如何使用C语言来实现一个非循环双向链表，包括带头结点和尾结点的链表。 首先，让我们定义链表节点的数据结构。在非循环双向链表中，每个节点包含两个指针，分别指向它的前一个节点和后一个节点。...
C语言实现带头结点尾结点的双向非循环链表的基本操作
10-09
以上代码实现了带头结点和尾结点的双向非循环链表的基本操作，包括创建、插入、删除、遍历和销毁链表。这样的链表设计能够方便地进行双向遍历，对于需要频繁在链表中间插入和删除节点的应用场景尤其有用。在C语言中...
循环链表和双向链表.ppt
09-20
在普通链表的基础上，带头结点的链表会在链表的第一个元素之前添加一个额外的节点，称为头结点。头结点不存储实际的数据，但可以用来存储链表的状态信息，如链表的长度。更重要的是，头结点使得对链表的某些操作变得...
数据结构之不带头结点的单链表
热门推荐
qq_43411563的博客
04-20 1万+
我们都知道不管是单链表、双向链表还是循环链表，都带有头结点，这个头结点相当于一个起始的位置。我们在设计带头结点的单链表的时候，我们会在主函数中设计一个头结点，并把它的指针域置为空，这样我们就可以进行增删查改这些操作了。那我们今天这篇博客就来说一下不带头结点的单链表。 一、不带头结点的单链表的定义 我们先来回忆一下带头结点的单链表是什么样子。如下图所示：红色的区域就是头结点，它有一个头指针指向它。 ...
数据结构实验报告（二）——不带头结点的单链表
future_dreaming的博客
01-10 1065
不带头结点的单链表的系列操作
链表经典题型(不带头结点)
m0_69356256的博客
12-21 299
链表经典题型
不带头结点双链表
qq_44313416的博客
03-22 111
王道2024考研数据结构，不带头结点双链表
C语言——链表（带头节点与不带头节点）
m0_73771309的博客
07-18 1294
链表是一种常见的线性数据结构，它由一系列的节点组成，每个节点包含两部分：数据和指向下一个节点的指针。每个节点可以在内存中不连续地分布，通过指针将它们串联在一起。下面呢，进入正题！！！首先呢，我们先看这张图！这是带头节点，带头节点的链表是在链表头部添加了一个额外的节点，该节点不存储任何数据，只是作为链表的起始位置。带头节点的链表中，头节点的下一个节点才是实际存储数据的第一个节点。
单链表带头结点与不带头结点
weixin_48443703的博客
11-02 1970
带头结点的链表会多用一个节点的空间，但我们通常都采用这种链表表示，为什么？？？ 带头结点与不带头结点的区别： 两者区别： 1、不带头结点的单链表对于第一个节点的操作与其他节点不一样，需要特殊处理，这增加了程序的复杂性和出现bug的机会，因此，通常在单链表的开始结点之前附设一个头结点。 2、带头结点的单链表,初始时一定返回的是指向头结点的地址，所以一定要用二维指针，否则将导致内存访问失败或异常。 3、带头结点与不带头结点初始化、插入、删除、输出操作都不样，在遍历输出链表数据时，带头结点的判断条件是while(
不带头结点单链表的基本操作
fallingskies
03-05 2520
定义结点 typedef struct LNode{ int data; //每个节点存放一个数据元素 struct LNode *next; //指针指向下一个节点 }LNode,*LinkList; //LinkList等价于LNode *,前者强调链表，后者强调结点 初始化 //初始化一个空的单链表 bool InitList(LinkList &L){ L = NU...
链表：带头结点和不带头结点
默默的博客
02-15 3413
链表：带头结点和不带头结点
数据结构——单链表(不带头节点)
Jambo!的博客
04-01 2921
单链表
循环双链表适合带头结点还是不带头结点
05-15
循环双链表可以同时带头结点和不带头结点，具体应该根据实际情况来选择使用哪种方式。 如果不带头结点，需要在插入和删除操作时分别处理头节点和尾节点的情况，比较繁琐。 如果带头结点，则可以在头结点中记录链表的长度，方便统计链表长度和遍历整个链表。同时，对于插入和删除操作，不需要特别处理头节点和尾节点的情况，使得代码更加简洁。 因此，如果需要频繁地进行插入和删除操作，建议使用带头结点的循环双链表。如果只需要遍历和查找操作，不需要频繁的插入和删除操作，可以考虑使用不带头结点的循环双链表。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值