单链表与双链表的结构笔记

原创 已于 2022-06-14 23:33:51 修改 · 176 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #链表 #c++

于 2022-06-05 23:55:30 首次发布
本文详细介绍了链表的基本使用、带头和不带头插入的区别，涵盖了头插法和尾插法创建单链表和双链表的方法，以及循环链表的实现。通过实例代码演示了如何在实际编程中运用这些技术。

通过代码的探索，了解链表基本的使用方法，以及带头插入和不带头插入，头插法和尾插法的区别

#include <iostream>
#include <malloc.h>
using namespace std;
//链表结构 
typedef struct LNode{
	int data;
	struct LNode *next;
}LNode,*LinkList; 

//双链表结构 
typedef struct DNode{
	int data;
	struct DNode *next,*prior;
}DNode,*DLinkList; 
//创建一个带头节点的单链表（头插法）
LinkList FrontLinkListWithHead(LinkList &L){
	LNode *s;int x;
	L = (LinkList)malloc(sizeof(LNode));
	L->data = -1;
	L->next = NULL;
	while(true){
		scanf("%d",&x);
		if(x==2022)break;
		s = (LNode *)malloc(sizeof(LNode));
		s->next = L->next;
		s->data = x;
		L->next = s;
	}
	return L;
} 
//创建一个不带头节点的单链表（头插法）
LinkList FrontLinkListWithoutHead(LinkList &L){
	LNode *s;int x;
	L = (LinkList)malloc(sizeof(LNode));
	scanf("%d",&x);
//注意退出情况
    if(x==2022)return NULL;
	L->data = x;
	L->next = NULL;
	while(true){
		scanf("%d",&x);
		if(x==2022)break;
		s = (LNode *)malloc(sizeof(LNode));
		s->next = L;
		s->data = x;
		L = s;
	}
	return s;
} 
//创建一个带头节点的单链表（尾插法）
LinkList BackLinkListWithHead(LinkList &L){
	LNode *s,*p;int x;
	L = (LinkList)malloc(sizeof(LNode));
	L->data = -1;
	L->next = NULL;
	p = L;
	while(true){
		scanf("%d",&x);
		if(x==2022)break;
		s = (LNode *)malloc(sizeof(LNode));
		s->next = NULL;
		s->data = x;
		p->next = s;
		p = s;
	}
	return L;
} 

//创建一个不带头节点的单链表（尾插法）
LinkList BackLinkListWithoutHead(LinkList &L){
	LNode *s,*p;int x;
	L = (LinkList)malloc(sizeof(LNode));
	scanf("%d",&x);
//注意退出情况
    if(x==2022)return NULL;
	L->data = x;
	L->next = NULL;
	p=L;
	while(true){
		scanf("%d",&x);
		if(x==2022)break;
		s = (LNode *)malloc(sizeof(LNode));
		s->next = NULL;
		s->data = x;
		p->next = s;
		p = s;
	}
	return L;
} 

//删除单链表中指定位置的元素(不算头节点的情况） 
void deletelinklist(LinkList &L,int i){
	LNode *p=L->next,*a;int k=1;
	while(++k<i-1 && p){ 
		p = p->next;
	}
	a = p->next;
	p->next = p->next->next;
	free(a);
} 

//创建一个带头节点的双链表（头插法）
DLinkList FrontDLinkListWithHead(DLinkList &L){
	 DNode *s; int x;
	 L = (DLinkList)malloc(sizeof(DNode));
	 L->data = -1;
	 L->prior = NULL;
	 L->next = NULL;
	 while(true){
	 	scanf("%d",&x);
	 	if(x==2022)break;
	 	s = (DNode *)malloc(sizeof(DNode));
	 	s->data = x;
	 	s->next = L->next;
	 	s->prior = L;
	 	if(L->next!=NULL){
	 		L->next->prior = s;
		}
		L->next = s; 
	 }
	 return L;
} 

//创建一个不带头节点的双链表（头插法）
DLinkList FrontDLinkListWithoutHead(DLinkList &L){
	 DNode *s; int x;
	 L = (DLinkList)malloc(sizeof(DNode));
	 scanf("%d",&x);
//注意退出情况
    if(x==2022)return NULL;
	 L->data = x;
	 L->prior = NULL;
	 L->next = NULL;
	 while(true){
	 	scanf("%d",&x);
	 	if(x==2022)break;
	 	s = (DNode *)malloc(sizeof(DNode));
	 	s->data = x;
	 	s->next = L;
	 	s->prior = NULL;
	 	L = s;
	 }
	 return s;
}

//创建一个带头节点的双链表（尾插法）
DLinkList BackDLinkListWithHead(DLinkList &L){
	DNode *s,*p;int x;
	L = (DLinkList)malloc(sizeof(DNode));
	L->data = -1;
	L->next = NULL;
	L->prior = NULL;
	p=L;
	while(true){
		scanf("%d",&x);
		if(x==2022)break;
		s = (DNode *)malloc(sizeof(DNode));
		s->next = NULL;
		s->prior = p;
		s->data = x;
		p->next = s;
		p = s;
	}
	return L;
} 

//创建一个不带头节点的双链表（尾插法）
DLinkList BackDLinkListWithoutHead(DLinkList &L){
	DNode *s,*p;int x;
	L = (DLinkList)malloc(sizeof(DNode));
	scanf("%d",&x);
//注意退出情况
    if(x==2022)return NULL;
	L->data = x;
	L->next = NULL;
	L->prior = NULL;
	p=L;
	while(true){
		scanf("%d",&x);
		if(x==2022)break;
		s = (DNode *)malloc(sizeof(DNode));
		s->next = NULL;
		s->prior = p;
		s->data = x;
		p->next = s;
		p = s;
	}
	return L;
} 

//打印单链表数据 
void printLinkList(LinkList L){
	while(L){
		if(L->data == -1){
			L = L->next;
			printf("本链表含有头节点:");
			continue; 
		}
		printf("%d,",L->data);
		L = L->next;
	}
} 

//打印双链表数据 
void printDLinkList(DLinkList L){
	while(L){
		if(L->data == -1){
			L = L->next;
			printf("本链表含有头节点:");
			continue; 
		}
		printf("%d,",L->data);
		L = L->next;
	}
} 

//删除双链表中指定位置的元素(不算头节点的情况） 
void deleteDlinklist(DLinkList &L,int i){
	DNode *p=L->next,*a;int k=1;
	while(++k<i-1 && p){ 
		p = p->next;
	}
	a = p->next;
	p->next->next->prior = p; 
	p->next = p->next->next;
	free(a);
}

//创建一个带头节点的循环单链表（头插法）
LinkList FrontCycleLinkListWithHead(LinkList &L){
	//初始化节点s暂存新节点，x为暂存值 
	LNode *s;int x; 
	//空间开辟 
	L = (LinkList)malloc(sizeof(LNode));
	//头节点建立，值为-1代表空 
	L->data = -1;
	//循环单链表，头部指向自己 
	L->next = L;
	//循环创建元素 
	while(true){
		//检测输入 
		scanf("%d",&x);
		//终止操作 
		if(x==2022)break;
		//新节点开辟空间 
		s = (LNode *)malloc(sizeof(LNode));
		//新节点继承后继节点 
		s->next = L->next;
		//新节点赋值 
		s->data = x;
		//头节点指向新节点 
		L->next = s;
	}
	//返回新链表的首地址 
	return L;
} 
//创建一个不带头节点的循环单链表（头插法）
LinkList FrontCycleLinkListWithoutHead(LinkList &L){
	//初始化节点s暂存新节点，x为暂存值 
	LNode *s;int x;
	//空间开辟 
	L = (LinkList)malloc(sizeof(LNode));
	//首元节点建立，值用户自定义 
	scanf("%d",&x);
	//空链表操作 
    if(x==2022)return NULL;
    //首元节点赋值 
	L->data = x;
	L->next = NULL;
	//循环创建链表 
	while(true){
		//检测输入 
		scanf("%d",&x);
		//终止操作 
		if(x==2022)break;
		//新节点开辟空间 
		s = (LNode *)malloc(sizeof(LNode));
		//新节点继承后继节点 
		s->next = L;
		//新节点赋值 
		s->data = x;
		//头节点指向新节点 
		L = s;
	}
	//返回新链表的首地址 
	return s;
} 

//创建一个带头节点的循环单链表（尾插法）
LinkList BackCycleLinkListWithHead(LinkList &L){
	//初始化暂存节点s 尾节点指针p（前驱节点） 暂存变量x 
	LNode *s,*p;int x;
	//空间开辟 
	L = (LinkList)malloc(sizeof(LNode));
	//节点赋值 
	L->data = -1;
	L->next = NULL;
	//尾节点指向头节点 
	p = L;
	//循环创建链表 
	while(true){
		//输入值 
		scanf("%d",&x);
		//检测终止操作 
		if(x==2022)break;
		//新节点开辟空间 
		s = (LNode *)malloc(sizeof(LNode));
		//新节点是尾插，后面节点为空 
		s->next = NULL;
		//新节点赋值 
		s->data = x;
		//前驱节点链接新节点 
		p->next = s;
		//前驱更新成当前节点 
		p = s;
	}
	//前驱节点指向头节点，构成循环链表 
	p->next = L; 
	//返回头节点地址 
	return L;
} 

//创建一个不带头节点的单链表（尾插法）
LinkList BackCycleLinkListWithoutHead(LinkList &L){
	//初始化暂存节点s 尾节点指针p（前驱节点） 暂存变量x 
	LNode *s,*p;int x;
	//空间开辟 
	L = (LinkList)malloc(sizeof(LNode));
	//输入x的值 
	scanf("%d",&x);
	//终止操作 
	if(x==2022)return NULL; 
	//首元节点赋值 
	L->data = x;
	L->next = NULL;
	//前驱节点更新为首元节点 
	p=L;
	//遍历插入链表 
	while(true){
		//输入X 
		scanf("%d",&x);
		//检测到特定值终止 
		if(x==2022)break;
		//空间开辟 
		s = (LNode *)malloc(sizeof(LNode));
		//新节点是尾插，后面节点为空 
		s->next = NULL;
		//新节点赋值 
		s->data = x;
		//前驱节点链接新节点 
		p->next = s;
		//前驱更新成当前节点 
		p = s;
	}
	//前驱节点指向首元节点，构成循环链表 
	p->next = L; 
	//返回头节点地址 
	return L;
} 

int main(){
	//单链表的测试数据 
	LinkList L;
	L = FrontLinkListWithoutHead(L);
	printLinkList(L);
	printf("\n");
	deletelinklist(L,3);
	printLinkList(L);
	printf("双链表测试开始\n"); 
    //双链表的测试数据
	DLinkList L1;
	L1 = BackDLinkListWithHead(L1);
	deleteDlinklist(L1,3);
	printDLinkList(L1); 
	return 0; 
}

总结：带头插入与不带头插入的区别取决于第一个结点是否含有有效的数据，同时需要注意的是头插法与尾插法是否含有头节点的代码区别。头插法节点区别较大，以下为您展开讲解。

头插法：

当您使用头插法含有头节点时，您只需在头节点后面挂载元素，并使新的元素指向后续的元素即可。

当您使用头插法不包含头节点时，将头节点视为一个指针，这个指针始终指向第一个含有元素的节点。当您继续添加元素时，这个指针在最后会更新指向此节点的数据，注意最后返回的新生成节点的地址。

以上代码仅供参考，如有错误请大家指正，谢谢！

Go语言学习笔记【10】 数据结构之单链表、双链表、循环链表
LC520730的博客
08-10 605
go实现单链表的头/尾部插入、删除，头尾元素的获取，判断元素是否包含，链表反转，循环链表及Josephus问题
【数据结构】第二章 线性表（时间复杂度、顺序表、链表、单链表、双向链表）代码分析详细
weixin_45991687的博客
04-01 3914
【数据结构】第二章 线性表（时间复杂度、顺序表、链表、单链表、双向链表）代码分析详细
双向链表
qq_43783527的博客
03-14 208
package com.atguigu.linkedlist; public class DoubleLinkedListDemo { public static void main(String[] args) { // 测试 System.out.println("双向链表的测试"); // 先创建节点 HeroNode2 hero1 = new HeroNode2(1,...
单/双向链表浅谈
daydreamqun的博客
04-10 723
链表浅谈 再一次接触链表发现链表已经比最初很容易上手了，第二次学链表让我觉得链表最重要的是它的思想，代码是属于理解了就会很容易上手。 So，谈谈思想。 一.单向链表 单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向表中的下一个节点，而最后一个节点则指向一个空值NULL。 单向链表只可向一个方向遍历。 查找一个节点的时候需要从第一个节点开始每次访问下一个节点，一直访问到需要的位置。也可以...
数据结构5——单链表与双链表（超全）
zxdznyy的博客
06-06 2652
文章目录前言一、链表1.单链表2.双链表二、单链表1.成员变量2.getSize()和isEmpty()3.链表的虚拟头节点1.什么是链表的虚拟头结点2.代码4.链表的基础方法1.向链表中添加节点2.链表中删除节点3.找到index处的元素4.查找是否有该元素5.知索引获取元素5.打印链表5.整体的代码实现三.双链表1.双链表的结构2.双链表的成员变量3.与单链表的不同之处1.双链表中增加元素2.双链表中删除元素4.整体代码实现总结 前言 本节讲述的是单链表与双链表基础方法的原理及实现，双链表将在单链表的
线性表中的顺序表与链表（单链表、双链表、环形链表）的特点
yqqの博客
05-05 3383
顺序表 顺序表根据索引查询元素的特点 因为顺序表（此处，也就是数组）的内存空间是连续的，并且存储的数据属于相同数据类型。 因此，我们可以通过数组的“首地址+索引”就能快速的找到数组中对应索引的元素值，从而得出数 组的优点：查找快。 索引操作数组原理：数组首地址 + 存放数据的字节数*索引。 顺序表删除元素的特点 需求：删除数组{11， 22， 33， 44， 55， 66}索引为 2 的元素，删除后的数组为：{11， 22， 44， 55， 66}。 实现步骤： (1) 把删除索引之后的元素往前挪动一位
单向链表和双向链表有什么区别？各自有什么优缺点？
tanshunlin的博客
11-17 3795
单向链表和双向链表有什么区别？各自有什么优缺点？
数据结构自学笔记（四）：单链表，双链表，循环链表和静态链表
Dddd11111120的博客
07-03 526
链表核心知识点摘要 单链表：通过指针链接节点，含数据域和指针域。带头结点版本操作更统一，支持按位序插入/删除（O(n)）、指定结点后插（O(1)）等操作。双链表引入前驱指针，支持双向遍历，插入删除需同步更新prior/next指针。循环链表（单/双）首尾相连，静态链表用数组模拟指针。优缺点：单链表节省空间但单向遍历；双链表操作灵活但结构复杂；循环链表避免遍历找尾；静态链表适合无指针环境但容量固定。关键操作均需注意边界处理（头尾结点）。
AcWing算法基础课第二讲(1):单链表、双链表、栈、队列、单调栈、单调队列、KMP
weixin_45029883的博客
01-07 1719
单链表、双链表、栈、队列、单调栈、单调队列、KMP
【数据结构】链表之LinkedList（无头双链表实现 + 详解 + 原码）
明志の博客
07-26 1990
LinkedList是无头双向非循环链表学习链表的知识一定要 结合图，多画图，才能深刻理解LinkedList官方文档LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节 点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。在集合框架中， LinkedList也实现了List接口。
Python 实现数据结构中的单链表，循环单链表，双链表
2401_84010884的博客
04-12 789
print(‘]’)ifname== ‘main’:print(‘--------判断是否为空-------’)print(‘-----------长度------------’)print(‘-----------遍历------------’)print(‘-----------遍历------------’)print(‘-----------查找------------’)print(‘-----------删除------------’)
【数据结构】谈谈单链表和双链表
阳阳的博客
03-26 4005
首先谈谈数组和单链表的区别 数组的特点 在内存中连续 利用下标定位元素，因此查找操作的时间复杂度为O(1) 增加与删除元素时，需要进行移动，因此增加与删除操作的时间复杂度为O(n) 数组大小固定，不能直接扩容。如果需要扩容，也是创建一个更大的数组，再将元素复制过去。 链表的特点 在内存中可以不连续 增加与删除元素的操作很方便，只需要移动指针，不需要移动元素，因此增加与删除的操作的时间...
单链表、双向链表、循环链表
hyt1152860391的博客
07-26 7594
常见链表 学习三种常见的链表结构，他们分别是：单链表、双向链表和循环链表。 单链表 单链表有两个较特殊节点，头结点和尾节点。头结点用来记录链表的基地址，可以用来遍历整条链表。尾结点的指针不是指向下一个节点而是指向一个空地址NULL，表示链表上的最后一个节点。 和数组一样，链表也支持数据的查找、插入和删除操作。但相对于数据的插入删除需要做大量的搬移操作，链表的插入，删除的时间复杂度为O(1)。但是链...
数据结构01- 单链表、双端链表、双向链表、无序链表、有序链表
琦彦
03-31 6706
数据结构01- 单链表、双端链表、双向链表、无序链表、有序链表 0、节点 节点 是数据结构中的基础，是 构成复杂数据结构的基本组成单位。 public class Node { public long data; public Node next; public Node(long value) { this.data = value; } } 1、链表的定义 链表： 通常由一连串 节点 组成，每个节点包含任意的实例数据（data fields）和一或两个用来指向 上一个 或 下一个
单链表的定义、特点、结构及其一些基本操作
热门推荐
HelloWorld
10-14 1万+
一，基本运算 1，单链表，双链表的定义： 设计链式存储结构时，每个逻辑节点存储单独存储。 2，单链表的基本结构： 头节点在前，首节点在后。 3，顺序表与链表间存储密度的差异： 顺序表的存储密度为1，而链表的存储密度小于1。 4， typedef struct LNode { ElemType data; //存放元素值 struct LNode *...
redis基础（数据结构）
weixin_74390886的博客
12-11 654
zrangebyscore key min max:按照score排序后，获取指定score范围内的元素。hsetnx:添加一个hash类型的key的field值，前提是这个field不存在，否则不执行。hset key field value:添加或者修改hash类型key的field的值。hgetall:获取一个hash类型的key中的所有的field和value。hget key field:获取一个hash类型key的field值。
数据结构04——二叉树搜索树BST
最新发布
moranxiao199的博客
12-16 425
Find查找的效率取决于树的高度，所以我们希望这个树尽量的平衡，不要出现一边倒。支持：查找（Search）、插入（Insert）、删除（Delete）第三种，删除的结点有左、右两颗子树：用另一个结点代替被删除的结点，同一组元素，如果插入顺序不同，二叉搜索树的形态可以完全不同。② 如果 X 大于根结点的关键值，在右子树中进行继续搜索；③ 若两者比较结果相等，搜索完成，返回指向此结点的指针。查找从根结点开始，如果树为空，返回 NULL。：将其父结点的指针指向被删除结点的孩子结点。
数据结构：矩阵
闲余知道
12-16 557
数据结构：矩阵
八大排序之：冒泡排序、快速排序和堆排序
t2786024916的博客
12-16 661
冒泡排序（Bubble Sort）是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。这个算法的名称由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端（升序排列）。
单链表的实现与数据结构学习笔记
而在插入操作中，则需注意调整新节点与前后节点之间的指针关系，确保链表结构不被破坏。 除此之外，单链表的时间复杂度特性也是学习的重点之一。访问第i个元素的时间复杂度为O(n)，因为必须从头开始逐个遍历；而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值