数据结构【有头双向链表】

于 2024-07-30 00:49:43 发布
阅读量510 收藏 15
点赞数 18
分类专栏： 【初阶】数据结构 文章标签： 数据结构 链表 c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_67578580/article/details/140596019
版权

目录

实现双向链表

双向链表数据

创建双向链表

初始化双向链表创建（哨兵位）

尾插

打印双向链表

头插

布尔类型

尾删

头删

查询

指定位置后插入

指定位置删除数据

销毁

顺序表和链表的分析

代码

list.h

list.c

test.c

注意：这⾥的“带头”跟前⾯我们说的“头结点”是两个概念，实际前⾯的在单链表阶段称呼不严 谨，但是为了同学们更好的理解就直接称为单链表的头结点。

带头链表⾥的头结点，实际为“哨兵位”，哨兵位结点不存储任何有效元素，只是站在这⾥“放哨 的”。

实现双向链表

创建3个文件，list.h头文件，list.c存放函数的文件，test.c测试文件

双向链表数据

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>

typedef int data;
typedef struct list
{
	data arr;//存放的数据
	struct list* prev; //节点头（上一个）
	struct list* next; //节点尾（下一个）
}SL;
创建双向链表

双向链表是：带头，双向，循环。

tab->arr存放x数值，双向链表是带循环的，所以节点头和节点尾要指向自己，

tab->next节点尾和tab->prev节点头指向自己。

然后返回当前节点。

//创建双向链表
SL* cjsxlb(data x)
{
	SL* tab = (SL*)malloc(sizeof(SL));
	if (tab == NULL)
	{
		perror("malloc");
		exit(1);
	}
	tab->arr = x;
	tab->next = tab->prev = tab;
	return tab;
}
初始化双向链表创建（哨兵位）

双向链表要带头，所以我们需要创建一个哨兵位head这个哨兵位不能修改。

//初始化
void csh(SL** r);//二级指针的方法
//SL* csh();//一级指针方法

    SL* add = NULL;//二级指针
	csh(&add);

	//SL* add = csh();//一级指针

二级指针：传地址过来可以直接修改到实参。

一级指针：需要add接收创建的哨兵位，然后返回。

//初始化
void csh(SL** r)//二级指针
{
	//创建链表
	*r = cjsxlb(-1);

}

//初始化
//SL* csh()//一级指针
//{
//	//创建链表
//	SL*add = cjsxlb(-1);
//	return add;
//}
尾插

尾插用一级指针就行了，我们不用修改哨兵位。

//尾插
void weic(SL* r,data x);

tab是新的双向链表空间

第一步：tab节点头 ，指向前一个节点。

第二步：tab节点尾，指向哨兵位节点。

第三步：tab前一个节点的节点尾指向tab。

第四步：哨兵位节点头指向tab。

//尾插
void weic(SL* r, data x)
{
	assert(r);
	SL* tab = cjsxlb(x);
	//先让新节点的头连接前一个节点
	tab->prev = r->prev;
	//新节点的尾连接哨兵位
	tab->next = r;
	//在让新节点的前一个节点连接新的节点头
	r->prev->next = tab;
	//让哨兵位的头指向新的节点
	r->prev = tab;
}

尾插的1,2,3,4

//尾插
	weic(add, 1);
	weic(add, 2);
	weic(add, 3);
	weic(add, 4);
	day(add);
打印双向链表

//打印
void day(SL* r);

打印哨兵位没什么用，所以我们从哨兵位下一个节点开始打印

把下一个节点给add， 循环不等于哨兵位，打印每个节点存放的数据。

//打印
void day(SL* r)
{
	SL* add = r->next;
	while (add != r)
	{
		printf("%d->", add->arr);
		add = add->next;
	}
	printf("\n");

}
头插

//头插
void toc(SL* r,data x);

第一步：tab的节点尾指向，哨兵位的下一个节点。

第二步：tab节点头指向哨兵位。

第三步：哨兵位下一个节点的节点头指向tab.

第四步：哨兵位的尾指向tab.

//头插
void toc(SL* r, data x)
{
	assert(r);
	SL* tab = cjsxlb(x);
	//让新节点的尾指向哨兵位下一个节点
	tab->next = r->next;
	//新节点头指向哨兵位
	tab->prev = r;

	//哨兵位下一个节点头指向新节点
	r->next->prev = tab;
	//哨兵位位指向新节点
	r->next = tab;

}

头插了99

	//头插
	toc(&add, 99);
布尔类型

C语⾔原来并没有为布尔值单独设置⼀个类型，⽽是使⽤整数 0 表⽰假，⾮零值表⽰真。 在 C99 中也引⼊了 布尔类型 ，是专⻔表⽰真假的。

_Bool

布尔类型的使⽤得包含头⽂件<stdbool.h>

布尔类型变量的取值是： true 或者 false 

#define bool _Bool
#define false 0
#define true 1
尾删

我们不能删除哨兵位，所以我们需要布尔类型来判断，当前节点是不是只有一个哨兵位，只有哨兵位不能删除。

//bool
bool list(SL* r);
//尾删除
void weisc(SL* r);

布尔类型，判断哨兵位的尾指向的是自己就返回真。

//布尔类型
bool list(SL* r)
{
	assert(r);
	//哨兵位指向的下一个节点等于哨兵位返回真
	return r->next == r;
}

布尔类型判断接收，（！逻辑非）把真变假，把假变真。

第一步：把最后一个节点给add。

第二步：把add前一个节点给tab。

第三步：tab的尾指向哨兵位。

第四步：哨兵位的头指向tab。

第五步：释放add空间。

//尾删除
void weisc(SL* r)
{
	assert(r);
	//布尔类型判断
	assert(!list(r));
	//把最后一个节点给add
	SL* add = r->prev;
	//把最后一个节点的前一个节点给tab
	SL* tab = add->prev;
	//tab尾指向哨兵位
	tab->next = r;
	//哨兵位头指向tab
	r->prev = tab;
	//释放add
	free(add);
	add = NULL;
}

我们可以看到把4删除了。

//尾删除
	weisc(&add);
头删

头删不是删哨兵位，是删除哨兵位的下一个节点。

//头删除
void tosc(SL* r);

布尔类型判断接收，（！逻辑非）把真变假，把假变真。

第一步：把哨兵位下一个节点给add。

第二步：把add下一个节点的头指向哨兵位。

第三步：哨兵位的尾指向add下一个节点。

第四步：释放add空间。

//头删除
void tosc(SL* r)
{
	assert(r);
	//布尔类型判断
	assert(!list(r));
	//哨兵位的下一个节点
	SL* add = r->next;

	//add下一个节点的头指向哨兵位
	add->next->prev = r;
	//哨兵位的尾指向add的下一个节点
	r->next = add->next;
	free(add);
	add = NULL;

}

把1删除了

    //头删除
	tosc(&add);
查询

//查找
SL* cz(SL* r, data x);

从哨兵位下一个节点开始循环查找，找到了返回当前空间就好了。

//查找
SL* cz(SL* r, data x)
{
	assert(r);
	//从哨兵位下一个节点开始
	SL* add = r->next;
	while (add != r)
	{
		if (add->arr == x)
		{
			return add;
		}
		add = add->next;
	}
	return NULL;

}

SL* tab = cz(add, 1);
	/*if (tab == NULL)
	{
		printf("没有找到\n");
	}
	else
	{
		printf("找到了\n");
	}*/
指定位置后插入

这原理和头插一样

//指定位置后插入
void zhidcr(SL* tab, data x);

第一步：add的节点尾指向，tab的下一个节点。

第二步：add节点头指向tab。

第三步：tab下一个节点的节点头指向add.

第四步：tab的尾指向add.

//指定位置后插入
void zhidcr(SL* tab, data x)
{
	SL* add = cjsxlb(x);
	//新节点的尾指向tab的下一个节点
	add->next = tab->next;
	//新节点的头指向tab
	add->prev = tab;
	//tab下一个节点的头指向add
	tab->next->prev = add;
	//tab节点的尾指向add
	tab->next = add;

}

我们可以看到在1后面插入了一个99。

//指定位置后插入
	zhidcr(tab, 99);
指定位置删除数据

这个的原理和头删除一样，把哨兵位当做tab的上一个节点就可以了。


//指定位置删除
void zhidsc(SL* tab);

先把tab给add

第一步：把add上一个节点的尾指向add的下一个节点。

第二步：把add的下一个节点的头指向add的上一个节点。

第三步：释放add或tab空间,都是指向一块空间的，然后置为NULL。

//指定位置删除
void zhidsc(SL* tab)
{
	assert(tab);
	SL* add = tab;
	//把add上一个节点的尾指向add的下一个节点
	add->prev->next = add->next;
	//把add的下一个节点的头指向add的上一个节点
	add->next->prev = add->prev;
	//释放add
	free(tab);
	tab = NULL;
}

我们可以看到把3删除了

//指定位置删除
	zhidsc(tab);
销毁

销毁我们需要把哨兵位后面的全部销毁完，再销毁哨兵位。

//销毁
//void ziaoh(SL** r);//二级指针

//销毁
void xiaoh(SL* r);//一级指针

第一步：先把哨兵位下一个节点给add。

第二步：循环销毁哨兵位后面的节点，

tab保存下一个节点，释放add空间，把tab空间给add。

第三步：释放哨兵位，把哨兵位置为NULL，在把add置为NULL。

//销毁
void xiaoh(SL* r)//一级指针
{
	//从哨兵位下一个节点开始销毁
	SL* add = r->next;
	while (add != r)
	{
		//tab保存下一个节点
		SL* tab = add->next;
		//释放
		free(add);
		//下一个节点赋值给add
		add = tab;
	}
	//释放哨兵位
	free(r);
	r = NULL;
	//把add置为空
	add = NULL;
}

//销毁
void xiaoh(SL** r)//二级指针
{
	//从哨兵位下一个节点开始销毁
	SL* add = (*r)->next;
	while (add != *r)
	{
		//tab保存下一个节点
		SL* tab = add->next;
		//释放
		free(add);
		//下一个节点赋值给add
		add = tab;
	}
	//释放哨兵位
	free(*r);
	r = NULL;
	//把add置为空
	add = NULL;
}

二级指针可以传地址过去可以修改到实参，销毁数据相当于销毁了实参。

一级指针不能修改到实参，所以我们销毁完，需要把实参置为NULL。


	//xiaoh(&add);//二级指针

	xiaoh(add);//一级指针
	add = NULL;

我们可以看到销毁成功了。

顺序表和链表的分析

不同点顺序表链表（单链表）
存储空间上物理上⼀定连续逻辑上连续，但物理上不⼀定连续
随机访问⽀持O(1)不⽀持：O(N)
任意位置插⼊或者删除元素可能需要搬移元素，效率低O(N)只需修改指针指向
插⼊动态顺序表，空间不够时需要扩 容和空间浪费没有容量的概念，按需申请释放，不存在 空间浪费
应⽤场景元素⾼效存储+频繁访问任意位置⾼效插⼊和删除

代码

list.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>

typedef int data;
typedef struct list
{
	data arr;//存放的数据
	struct list* prev; //节点头（上一个）
	struct list* next; //节点尾（下一个）
}SL;
//初始化
void csh(SL** r);//二级指针的方法
//SL* csh();//一级指针方法
//尾插
void weic(SL* r,data x);
//打印
void day(SL* r);
//头插
void toc(SL* r,data x);
//bool
bool list(SL* r);
//尾删除
void weisc(SL* r);
//头删除
void tosc(SL* r);
//查找
SL* cz(SL* r, data x);
//指定位置后插入
void zhidcr(SL* tab, data x);
//指定位置删除
void zhidsc(SL* tab);
//销毁
//void ziaoh(SL** r);//二级指针
//销毁
void xiaoh(SL* r);//一级指针
list.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"list.h"

//创建双向链表
SL* cjsxlb(data x)
{
	SL* tab = (SL*)malloc(sizeof(SL));
	if (tab == NULL)
	{
		perror("malloc");
		exit(1);
	}
	tab->arr = x;
	tab->next = tab->prev = tab;
	return tab;
}


//初始化
void csh(SL** r)//二级指针
{
	//创建链表
	*r = cjsxlb(-1);

}

//初始化
//SL* csh()//一级指针
//{
//	//创建链表
//	SL*add = cjsxlb(-1);
//	return add;
//}



//打印
void day(SL* r)
{
	SL* add = r->next;
	while (add != r)
	{
		printf("%d->", add->arr);
		add = add->next;
	}
	printf("\n");

}


//尾插
void weic(SL* r, data x)
{
	assert(r);
	SL* tab = cjsxlb(x);
	//先让新节点的头连接前一个节点
	tab->prev = r->prev;
	//新节点的尾连接哨兵位
	tab->next = r;
	//在让新节点的前一个节点连接新的节点头
	r->prev->next = tab;
	//让哨兵位的头指向新的节点
	r->prev = tab;
}


//头插
void toc(SL* r, data x)
{
	assert(r);
	SL* tab = cjsxlb(x);
	//让新节点的尾指向哨兵位下一个节点
	tab->next = r->next;
	//新节点头指向哨兵位
	tab->prev = r;

	//哨兵位下一个节点头指向新节点
	r->next->prev = tab;
	//哨兵位位指向新节点
	r->next = tab;

}

//布尔类型
bool list(SL* r)
{
	assert(r);
	//哨兵位指向的下一个节点等于哨兵位返回真
	return r->next == r;
}

//尾删除
void weisc(SL* r)
{
	assert(r);
	//布尔类型判断
	assert(!list(r));
	//把最后一个节点给add
	SL* add = r->prev;
	//把最后一个节点的前一个节点给tab
	SL* tab = add->prev;
	//tab尾指向哨兵位
	tab->next = r;
	//哨兵位头指向tab
	r->prev = tab;
	//释放add
	free(add);
	add = NULL;
}


//头删除
void tosc(SL* r)
{
	assert(r);
	//布尔类型判断
	assert(!list(r));
	//哨兵位的下一个节点
	SL* add = r->next;

	//add下一个节点的头指向哨兵位
	add->next->prev = r;
	//哨兵位的尾指向add的下一个节点
	r->next = add->next;
	free(add);
	add = NULL;

}



//查找
SL* cz(SL* r, data x)
{
	assert(r);
	//从哨兵位下一个节点开始
	SL* add = r->next;
	while (add != r)
	{
		if (add->arr == x)
		{
			return add;
		}
		add = add->next;
	}
	return NULL;

}


//指定位置后插入
void zhidcr(SL* tab, data x)
{
	SL* add = cjsxlb(x);
	//新节点的尾指向tab的下一个节点
	add->next = tab->next;
	//新节点的头指向tab
	add->prev = tab;
	//tab下一个节点的头指向add
	tab->next->prev = add;
	//tab节点的尾指向add
	tab->next = add;

}

//指定位置删除
void zhidsc(SL* tab)
{
	assert(tab);
	SL* add = tab;
	//把add上一个节点的尾指向add的下一个节点
	add->prev->next = add->next;
	//把add的下一个节点的头指向add的上一个节点
	add->next->prev = add->prev;
	//释放add
	free(tab);
	tab = NULL;
}



销毁
//void xiaoh(SL** r)//二级指针
//{
//	//从哨兵位下一个节点开始销毁
//	SL* add = (*r)->next;
//	while (add != *r)
//	{
//		//tab保存下一个节点
//		SL* tab = add->next;
//		//释放
//		free(add);
//		//下一个节点赋值给add
//		add = tab;
//	}
//	//释放哨兵位
//	free(*r);
//	r = NULL;
//	//把add置为空
//	add = NULL;
//}

//销毁
void xiaoh(SL* r)//一级指针
{
	//从哨兵位下一个节点开始销毁
	SL* add = r->next;
	while (add != r)
	{
		//tab保存下一个节点
		SL* tab = add->next;
		//释放
		free(add);
		//下一个节点赋值给add
		add = tab;
	}
	//释放哨兵位
	free(r);
	r = NULL;
	//把add置为空
	add = NULL;
}
test.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"list.h"

void p()
{
	SL* add = NULL;//二级指针
	csh(&add);

	//SL* add = csh();//一级指针
	
	//尾插
	weic(add, 1);
	weic(add, 2);
	weic(add, 3);
	weic(add, 4);
	day(add);

	头插
	//toc(&add, 99);
	尾删除
	//weisc(&add);
	头删除
	//tosc(&add);

	SL* tab = cz(add, 3);
	/*if (tab == NULL)
	{
		printf("没有找到\n");
	}
	else
	{
		printf("找到了\n");
	}*/
	//指定位置后插入
	//zhidcr(tab, 99);
	//day(add);

	//指定位置删除
	zhidsc(tab);
	day(add);

	//xiaoh(&add);//二级指针

	xiaoh(add);//一级指针
	add = NULL;

}

int main()
{
	p();
	return 0;

}

孤独且没人爱的纸鹤
关注
  • 18
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
数据结构 双向链表（C++）
06-07
双向链表是一种特殊的数据结构，它在计算机程序设计中扮演着重要角色，特别是在C++这样的编程语言中。本节将深入探讨双向链表的概念、其结构、操作以及C++中的实现。 双向链表与单链表不同，它允许每个节点不仅有一...
数据结构双向链表
09-24
双向链表是数据结构中的一种，与单链表相比，它提供了更多的灵活性。本篇将详细介绍双向链表及其C语言实现的基础操作。 双向链表是一种线性数据结构，每个节点包含数据部分以及两个指针，一个指向前一个节点（prev...
数据结构学习——双向链表
weixin_62410421的博客
05-03 5024
文章目录前言——双向链表含义一、双向链表结构（图解）二、 双向链表的实际操作1、 结构2、创建头结点3、打印4、插入5、定位6、删除完整代码运行结果 前言——双向链表含义 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 一、双向链表结构（图解） 二、 双向链表的实际操作 1、 结构 /** * Double linked list of integ
数据结构——双向链表
麦麦的博客
03-11 2160
数据结构——双向链表：本文对双向链表的功能实现进行了详细地讲解，并与单链表的实现进行对比，干货满满，图文并茂，过万好文，不容错过！！！
Java数据结构--双向链表
m0_74808313的博客
04-23 1653
在上一篇中我们学习了单向链表的实现，链表中我们除了单向链表还有双向链表，在这一篇我们将更进一步地了解链表，实现双向链表。
Java数据结构与算法——双向链表
★★光亭★★
03-11 6109
Java数据结构与算法——双向链表
数据结构之双向链表详解
小源_ 的博客
12-20 3469
本文着重讲解了LinkedList(无头双向单链表)的实现和LinkedList的使用。内附代码和图文分析，看完就会！
C语言实现数据结构和双向链表操作
01-21
数据结构 双向链表的实现 双向链表中的每一个结点都含有两个指针域，一个指针域存放其后继结点的存储地址，另一个指针域则存放其前驱结点的存储地址。 双向链表结点的类型描述： //双向链表的类型描述 typedef ...
java数据结构之实现双向链表的示例
09-04
在Java中，双向链表是一种重要的数据结构，它允许在链表中的元素之间进行前后双向导航。本示例将详细介绍如何在Java中实现一个简单的双向链表，并提供相关的操作方法。 双向链表由一系列节点组成，每个节点包含三个...
C语言 数据结构双向链表简单实例
08-31
C语言数据结构双向链表简单实例 本文主要介绍了C语言数据结构双向链表简单实例的相关知识点，包括双向链表的基本操作、删除元素、插入元素、判断对称性、排序等。 一、双向链表的基本操作 双向链表是一种数据结构...
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 308
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
数据结构之初始二叉树（4）
我要学编程的博客
07-22 1421
二叉树的前序遍历、二叉树的层序遍历、根据二叉树的前序和中序遍历构造二叉树、二叉树的最近公共祖先、根据二叉树创建字符串
【JavaScript】`Map` 数据结构
lph159的博客
07-25 365
允许您使用各种类型的值作为键，不限于字符串或符号。按照插入顺序保留键值对，而对象的键的遍历顺序可能会根据不同的 JavaScript 引擎有所不同。的基本概念、用法、常见操作以及与对象的对比，帮助您全面掌握这一数据结构。与传统的对象（Object）不同，和对象在某些方面类似，但它们在使用场景和性能上有一些显著区别。保留了键值对的插入顺序，且键是唯一的，这意味着在同一个。对象适用于结构化的静态数据，而。是一种键值对集合，其中键和值都可以是任意类型。对象的键只能是字符串或符号，而。更适合需要动态操作的场景。
【数据结构】队列
2302_78914800的博客
07-25 224
①队列是一个有序列表，可以用。
数据结构——堆
yyy_3yu的博客
07-24 896
堆，一种特殊的完全二叉树，论其定义：如果有一个关键码的集合K = { k0，k1 ，k2 ，…，kn-1 }，把它的所有元素按完全二叉树的顺序存储方式存储 在一个一维数组中，并满足：Ki=K2i+2）i = 0，1， 2…，则称为小堆(或大堆)。将根结点最大的堆叫做最大堆或大根堆，根结点最小的堆叫做最小堆或小根堆。
数据结构·红黑树
atlanteep的博客
07-25 846
本节讲解了红黑树的结构和实现，红黑树是通过节点颜色来满足它的前四条规则，使得搜索树近似平衡的。
数据结构经典测试题4
最新发布
c23856的博客
07-25 586
语句将'c'替换为'd'，字符串变更为"abddcccd"，同时指针it1加 加停在第四个字符'd'上，it2再次跳过字符'c'，停在最后一个'd'上，赋值后，字符串不变，再后移外层循环遇到0结束.p是char*类型，每次++，后移一个地址，char *p = str[0]相当于char *p = "stra"，p先指向其中的字符's'，printf输出遇到 0停止，第一次输出"stra"，p++后，指向字符't'，第二次输出"tra"，第三次输出"ra".上述代码运行结果是什么？上述代码运行结果是什么？
数据结构中的八大金刚--------八大排序算法
Miwll的博客
07-23 768
InsertSort(直接插入排序) ShellSort(希尔排序) BubbleSort(冒泡排序) HeapSort(堆排序) SelectSort(直接选择排序) QuickSort(快速排序) MergeSort(归并排序) CountSort(计数排序)
数据结构【没头单链表】
qq_67578580的博客
07-22 1478
图中指针变量plist保存的是第⼀个结点的地址，我们称plist此时“指向”第⼀个结点，如果我们希望 plist“指向”第⼆个结点时，只需要修改plist保存的内容为0x0012FFA0。链表中每个结点都是独⽴申请的（即需要插⼊数据时才去申请⼀块结点的空间），我们需要通过指针 变量来保存下⼀个结点位置才能从当前结点找到下⼀个结点。当我们想要保存⼀个整型数据时，实际是向操作系统申请了⼀块内存，这个内存不仅要保存整型数 据，也需要保存下⼀个节点的地址（当下⼀个节点为空时保存的地址为空）。
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值