数据结构--双链表，循环链表，静态链表代码（王道书上代码手敲！！！）c++

最新推荐文章于 2024-09-12 17:17:36 发布
最新推荐文章于 2024-09-12 17:17:36 发布
阅读量293 收藏 3
点赞数 3
文章标签： 数据结构 链表 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46281068/article/details/140755209
版权

目录

1.带头结点的双链表的初始化，判断链表是否为空，前插，后插，按位序插，删除后继节点，按位查找，按之查找，清空链表，销毁链表，遍历打印列表操作

2. 循环单链表初始化，判空，判断是否为尾节点

3.循环双链表初始化，判空，判断是否为尾节点，插入，删除后继元素，打印链表内容操作

4.静态链表的初始化，查找空节点，按位查找，按位插入，按位删除，遍历打印操作

注意！！！以下代码是在c++环境中写的c代码，用了c++代码的&

1.带头结点的双链表的初始化，判断链表是否为空，前插，后插，按位序插，删除后继节点，按位查找，按之查找，清空链表，销毁链表，遍历打印列表操作

代码：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <malloc.h>

//带头结点的双链表
//定义结构体
typedef struct DNode {
	int data;
	struct  DNode* prior, * next;
}DNode,*DLinklist;

//添加函数原型的声明
bool InitDLinkList(DLinklist& L);
bool Empty(DLinklist L);
bool InsertNextDNode(DNode* p, DNode* s);
bool  InsertPriorDNode(DNode* p, DNode* s);
bool InsertDNode(DLinklist& L, int i, DNode* s);
void PrintDList(DNode* L);
bool DeleteNextDNode(DNode* p);
DNode* GetElem(DLinklist L, int i);
DNode* LocateElem(DLinklist L, int e);
void ClearDList(DLinklist& L);
void DestroyDList(DLinklist& L);

//初始化双链表
bool InitDLinkList(DLinklist &L) {
	L = (DNode*)malloc(sizeof(DNode));		//申请了一片空间做为头节点，并且头指针L指向这个节点
	if (L == NULL) {
		printf("内存分配失败");
		return false;
	}
	L->prior = NULL;							//头结点的前向指针永远指向NULL
	L->next = NULL;								//头结点的下一个节点暂时还没有节点
	return true;
}

//判断链表是否为空
bool Empty(DLinklist L) {
	if (L->next == NULL)
		return true;
	else
		return false;
}

//后插操作，在p节点后插入s节点
bool InsertNextDNode(DNode *p,DNode *s) {
	if (p == NULL || s == NULL)		//非法参数
		return false;
	s->next=p->next;
	if(p->next!=NULL)	//如果p不是最后一个节点
		p->next->prior = s;
	s->prior = p;
	p->next = s;
	return true;
}

//双链表的前插操作,在p节点前插入节点s
bool  InsertPriorDNode(DNode *p,DNode *s) {
	if (p == NULL || s == NULL)				//非法参数
		return false;
	DNode* q = p->prior;	//找到p的前一个结点，在他后面进行后插
	InsertNextDNode(q, s);
	return true;
}

//实现按位序插入,实现逻辑，找到当前位序的前一个节点，在其后进行后插
bool InsertDNode(DLinklist &L, int i, DNode* s) {
	DNode *p= GetElem(L, (i - 1));
	//进行后插
	InsertNextDNode(p, s);
	return true;
}

// 打印双链表
void PrintDList(DNode* L) {
	DNode* p = L->next;		// 跳过头节点
	while (p != NULL) {
		printf("%d\n", p->data);
		p = p->next;
	}
	printf("NULL\n");
}

//删除p节点后的后继节点
bool DeleteNextDNode(DNode* p) {
	if (p == NULL || p->next == NULL)
		return false;
	DNode* q = p->next;
	p->next = q->next;
	if (q->next != NULL)
		q->next->prior = p;
	free(q);
	return true;
}

//按位查询双链表,查询第i个位置的节点，并返回该节点
DNode* GetElem(DLinklist L,int i) {
	DNode* p = L;
	int j = 0;
	while (p != NULL && j < i - 1) {
		p = p->next;
		j++;
	}
	if (p == NULL) // 如果p为空，说明i值过大
		return NULL;
	return p;
}

//按值查找
DNode* LocateElem(DLinklist L,int e) {
	DNode* p = L->next;			//聪第一个结点开始遍历，因为头结点的数据为NULL,无意义。
	while (p != NULL && p->data!=e) {
		p = p->next;
	}
	return p;
}

//清空双链表
void ClearDList(DLinklist &L) {
	while (L->next != NULL) {
		DeleteNextDNode(L);
	}
}

//销毁双链表
void DestroyDList(DLinklist &L) {
	ClearDList(L);
	free(L);		//释放头结点
	L = NULL;		//头指针指向NULL，使其链表结构彻底销毁
}

int main() {
	DLinklist L;
	InitDLinkList(L);
	
	//检查双链表是否为空
	printf("当前双链表是否为空：%s\n",Empty(L)?"是":"否");

	// 验证后插操作
	DNode* node1 = (DNode*)malloc(sizeof(DNode));
	node1->data = 1;
	InsertNextDNode(L, node1);
	printf("后插节点1后双链表的内容：\n");
	PrintDList(L);

	// 验证按位序插入操作
	DNode* node2 = (DNode*)malloc(sizeof(DNode));
	node2->data = 2;
	InsertDNode(L, 2, node2);
	printf("按位序插入节点2后双链表的内容：\n");
	PrintDList(L);

	// 验证前插操作
	DNode* node3 = (DNode*)malloc(sizeof(DNode));
	node3->data = 3;
	InsertPriorDNode(node2, node3);
	printf("前插节点3后双链表的内容：\n");
	PrintDList(L);

	// 验证按值查找操作
	int value = 2;
	DNode* result = LocateElem(L, value);
	if (result != NULL) {
		printf("找到值为%d的节点地址为：%d\n", value,result);
	}
	else {
		printf("未找到值为%d的节点\n", value);
	}

	// 清空双链表
	ClearDList(L);
	printf("清空双链表后：\n");
	PrintDList(L);

	// 销毁双链表
	DestroyDList(L);
	if (L == NULL) {
		printf("双链表已销毁\n");
	}
	else {
		printf("双链表销毁失败\n");
	}

	return 0;
}

结果：

2. 循环单链表初始化，判空，判断是否为尾节点

代码：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <malloc.h>

//循环单链表
//定义单链表结构体
typedef struct LNode {
	int data;
	struct LNode* next;
}LNode,*LinkList;

//添加函数原型的声明
bool InitList(LinkList& L);
bool Empty(LinkList L);
bool IsTail(LinkList L, LNode* p);

//链表初始化
bool InitList(LinkList &L) {
	//关于链表初始化是否需要将data设置为空的说法，回答如下：
	//主要是确保链表存在并且指针正确设置。
	//即头结点已经被分配内存并且 next 指针指向自己（循环链表）或 NULL（普通链表）。不需要设置data域为空
	L = (LNode*)malloc(sizeof(LNode));
	if (L == NULL)
		return false;
	L->next = L;
	return true;
}

//链表判空操作，判断链表是否为空
bool Empty(LinkList L) {
	if (L->next == L)
		return true;
	else
		return false;
}

//判断节点p是否为尾节点
bool IsTail(LinkList L,LNode *p) {
	if (p->next == L)
		return true;
	else
		return false;
}

int  main() {
	LinkList L;	//定义一个单链表
	InitList(L);
	
	//判空操作验证
	printf("该循环链表是否为空：%s\n", Empty(L) ? "是" : "否");

	//是否为尾节点验证
	LNode *p= (LNode*)malloc(sizeof(LNode));
	L->next = p;
	p->next = L;
	printf("该节点是否为尾节点：%s\n", IsTail(L,p) ? "是" : "否");

	return 0;
}

结果：

3.循环双链表初始化，判空，判断是否为尾节点，插入，删除后继元素，打印链表内容操作

代码：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <malloc.h>

//循环双链表
//定义单链表结构体
typedef struct LNode {
	int data;
	struct LNode *next,*prior;
}DNode, *DLinkList;

//函数原型的声明
bool InitDLinkList(DLinkList& L);
bool Empty(DLinkList L);
bool IsTail(DLinkList L, DNode* p);
bool InsertNextDNode(DNode* p, DNode* s);
bool DeleteDNode(LNode* p);
void PrintList(DLinkList L);

//初始化双链表
bool InitDLinkList(DLinkList &L) {
	L = (DNode*)malloc(sizeof(DNode));
	if (L == NULL)
		return false;
	L->next = L;
	L->prior = L;
	return true;
}

//判空操作
bool Empty(DLinkList L) {
	if (L->next == L)
		return true;
	else
		return false;
}

//判断节点p是否为尾节点
bool IsTail(DLinkList L, DNode *p) {
	if (p->next == L)
		return true;
	else
		return false;
}

//插入节点，在p节点后插入s节点
bool InsertNextDNode(DNode* p, DNode* s) {
	if (p == NULL || s == NULL) {
		return false;  // 如果 p 或 s 为空，则插入失败
	}
	p->next->prior = s;
	s->next=p->next;
	p->next = s;
	s->prior = p;
	return true;
}

//删除p节点的后继节点q
bool DeleteDNode(LNode *p) {
	if (p == NULL || p->next == NULL)
		return false;
	DNode* q = p->next;
	p->next = q->next;
	q->next->prior = p;
	free(q);
	return true;
}

// 打印链表内容
void PrintList(DLinkList L) {
	DNode* p = L->next;
	while (p != L) {
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

int  main() {
	DLinkList L;
	InitDLinkList(L);

	// 判空操作验证
	printf("该循环双链表是否为空：%s\n", Empty(L) ? "是" : "否");

	// 插入节点测试
	DNode* node1 = (DNode*)malloc(sizeof(DNode));
	node1->data = 1;
	InsertNextDNode(L, node1);

	DNode* node2 = (DNode*)malloc(sizeof(DNode));
	node2->data = 2;
	InsertNextDNode(node1, node2);

	DNode* node3 = (DNode*)malloc(sizeof(DNode));
	node3->data = 3;
	InsertNextDNode(node2, node3);

	// 打印链表内容验证插入操作
	printf("链表内容: ");
	PrintList(L);

	// 是否为尾节点验证
	printf("node3 是否为尾节点：%s\n", IsTail(L, node3) ? "是" : "否");

	// 删除节点测试
	DeleteDNode(node1); // 删除 node1 的后继节点 node2

	// 打印链表内容验证删除操作
	printf("删除 node2 后链表内容: ");
	PrintList(L);

	// 释放内存
	free(node1);
	free(node3);
	free(L);

	return 0;
}

结果：

4.静态链表的初始化，查找空节点，按位查找，按位插入，按位删除，遍历打印操作

代码：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <malloc.h>
#define MaxSize 10

// 静态链表定义
typedef struct {
    int data;       // 存储数据元素
    int next;       // 下一个元素的数组下标
} SLinkList[MaxSize];

//函数原型声明
bool InitSList(SLinkList& s);
int FindFreeNode(SLinkList s);
int FindLocate(SLinkList s, int i);
bool Insert(SLinkList& s, int i, int e);
int DeleteSNode(SLinkList& s, int i);
void PrintList(SLinkList s);

// 初始化链表
bool InitSList(SLinkList& s) {
    if (s == NULL)
        return false;
    s[0].next = -1;  // 头节点，next指向-1表示空链表
    for (int i = 1; i < MaxSize; i++) {
        s[i].next = -2;  // -2表示空闲节点
    }
    return true;
}

// 找到第一个空闲的元素，并返回它的下标
int FindFreeNode(SLinkList s) {
    for (int i = 0; i < MaxSize; i++) {
        if (s[i].next == -2) {
            return i;
        }
    }
    return -1;  // 没有空闲节点
}

// 找到位序为i的元素，并返回它的下标
int FindLocate(SLinkList s, int i) {
    int pos = 0;  // 指向头节点
    for (int j = 0; j < i && pos != -1; j++) {
        pos = s[pos].next;
    }
    return pos;
}

// 按位插入，在位序为i的位置插入值为e的节点
bool Insert(SLinkList& s, int i, int e) {
    if (i < 1 || i > MaxSize - 1) return false;  // 插入位置无效

    int prev = FindLocate(s, i - 1);  // 找到位序i-1的位置
    if (prev == -1) return false;  // 插入位置无效

    int freeNode = FindFreeNode(s);  // 找到一个空闲节点
    if (freeNode == -1) return false;  // 没有空闲节点

    s[freeNode].data = e;
    s[freeNode].next = s[prev].next;
    s[prev].next = freeNode;

    return true;
}

// 删除位序为i的节点，并返回删除节点的值
int DeleteSNode(SLinkList& s, int i) {
    if (i < 1 || i >= MaxSize) return -1;  // 删除位置无效

    int prev = FindLocate(s, i - 1);  // 找到位序i-1的位置
    if (prev == -1 || s[prev].next == -1) return -1;  // 删除位置无效

    int delNode = s[prev].next;  // 要删除的节点
    int e = s[delNode].data;  // 获取删除节点的数据
    s[prev].next = s[delNode].next;  // 跳过要删除的节点
    s[delNode].next = -2;  // 将删除的节点标记为空闲节点

    return e;
}

// 打印链表中的元素
void PrintList(SLinkList s) {
    int pos = s[0].next;  // 从头节点的下一个节点开始
    while (pos != -1) {
        printf("%d -> ", s[pos].data);
        pos = s[pos].next;
    }
    printf("NULL\n");
}

int main() {
    SLinkList s;
    if (InitSList(s)) {
        Insert(s, 1, 10);
        Insert(s, 2, 20);
        Insert(s, 1, 5);
        printf("初始链表: ");
        PrintList(s);

        int deletedValue = DeleteSNode(s, 2);
        printf("删除位序为2的节点后: ");
        PrintList(s);
        printf("删除的值: %d\n", deletedValue);
    }
    else {
        printf("链表初始化失败\n");
    }

    return 0;
}

 结果：

 结束~

有收获的宝宝留个赞赞再走吧~ 

不胜感激~

小羊爱敲代码
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构--顺序表、链表、栈、队列、树、文件（visual studio可运行）
m0_51152186的博客
12-28 1303
/数组下标从零开始，插入第一个位置，访问的下标为0//走到这里代表插入成功，返回true}//删除使用元素e的引用的目的是拿出对应的值{if(iL.length)//如果删除的位置是不合法//获取顺序表中对应的元素，赋值给ej
Git 教程 - Git 基本用法
u011679955的博客
03-25 5020
目录(?)[+] Git 教程 - Git 基本用法 您的评价:          收藏该经验 Git 是当前最流行的版本控制程序之一，文本包含了 Git 的一些基本用法 创建 git 仓库 初始化 git 仓库  mkdir project  # 创建项目目录  cd project  # 进入到项目目录  git init
送你一个励志故事——涵盖20多所互联网公司的校招C++面经
New life
04-23 4154
作者：守望者1028 链接：https://www.nowcoder.com/discuss/55353 来源：牛客网 终于有时间来回馈牛客了，接下来将继续我的学习历程（keep learning）。我的秋招故事很长很长，期间无穷多的心酸与苦难，当然也不乏兴奋与惊喜。写在这里，是对自己这段生活的一种怀念，更是想给目前还处于彷徨无助看不到希望的同学一种激励。这不是一篇纯粹的笔经面经，但我自认为...
2025考研 | 广西大学828计算机考研考研经验分享 | 有任何问题随便问
miku_web的博客
07-06 1392
广西大学828计算机考研经验分享，针对四门专业课和真题进行解析
送你一个励志故事—掌握这些你也可能拿到腾讯offer
WantFlyDaCheng的博客
11-27 1466
作者：守望者1028来源：牛客网终于有时间来回馈牛客了，接下来将继续我的学习历程（keep learning）。我的秋招故事很长很长，期间无穷多的心酸与苦难，当然也不乏兴...
送你一个励志故事（转载）
cfycyf的博客
08-14 1007
转载 MARK一下 作者：守望者1028 链接：https://www.nowcoder.com/discuss/55353 来源：牛客网   本面试主要分成三块内容： 第一部分：知识水平的提升方法与面试技巧，针对非科班或者知识面薄弱的同学，讲解准备校招与校招过程中应该具备的能力与技巧，包括但不限于推荐书单，技能说明，面试技巧等。 第二部分：大体上描述C++研发或者后台开发在笔试面试中高频出现...
git的详细用法和基础教程
qq_35840916的博客
05-15 4833
Git 是当前最流行的版本控制程序之一，文本包含了 Git 的一些基本用法 创建 git 仓库 初始化 git 仓库  mkdir project  # 创建项目目录  cd project  # 进入到项目目录  git init  # 初始化 git 仓库。此命令会在当前目录新建一个 .git 目录，用于存储 git 仓库的相关信息  初始化提交  touch READM
数据结构-链表的实现代码（C语言版）.rar
10-27
数据结构 -- C语言版 -- 链表的部分实现代码（单向链表、双向链表、循环链表、约瑟夫环等），详细介绍参考数据结构--链表的系列博文。链接为：https://blog.csdn.net/songshuai0223/category_9742561.html。
一、基础数据结构-1.链表-2.静态链表
01-17
一、基础数据结构-1.链表-2.静态链表
数据结构-基本算法-静态链表
05-21
数据结构-基本算法-静态链表（学生时代源码，调试可运行）
数据结构-链表结构-双向链表
qq_44715376的博客
08-01 3692
双向链表
数据结构算法——排序算法
qq_73643693的博客
09-07 843
数据结构中的常见算法——排序算法
栈的内容..
2301_79724394的博客
09-09 199
持续更新，小手动一动，点个关注，谢谢！
【华为OD】2024D卷——生成哈夫曼树
最新发布
weixin_45653183的博客
09-12 904
这是通过构建一种特殊的二叉树来实现的，其中每个字符都位于树的一个叶节点上，且该叶节点到根节点的路径上的边所代表的字符（在哈夫曼编码中通常使用0和1表示）共同构成了该字符的编码。·新节点作为这两个子节点的父节点，而原来的两个节点则成为新节点的左右子节点（通常约定左子节点频率小于等于右子节点）。2、不断从堆中取出两个最小的节点作为左右子树，构造一个新的父节点，其权值为两个节点权值之和，并将新节点插入堆中。·然后，算法反复地选择两个频率最小的节点，将它们合并为一个新的节点，新节点的频率是两个子节点频率之和。
【数据结构】基本概念和术语
Sakura_ding的博客
09-09 906
是指一个数学模型以及定义在该模型上的一组操作。抽象数据类型的定义仅取决于它的一组逻辑特性，而与其在计算机内部如何表示和实现无关，即不论其内部结构如何变化，只要它的数学特性不变，都不影响其外部的使用。抽象数据类型和数据类型实质上是一个概念。“抽象”的意义在于数据类型的数学抽象特性。抽象数据类型的定义由一个值域和定义在该值域上的一组操作组成。若按其值的不同特性，可细分为下列三种类型：原子类型 (atomic data type)属原子类型的变量的值是不可分解的。
C语言代码练习(第十八天)
2201_75306399的博客
09-09 1255
C语言代码练习
数据结构 栈 队列
qq_69971969的博客
09-06 620
数据的插入--->入栈 数据的删除----->出栈。函数的调用关系（保护现场，恢复现场操作，遵循先进后出，后进先出）缓存数据：主要使用队列，类似于缓冲区，防止数据丢失。允许从一端插入数据，另一端删除数据的线性存储结构。只允许从一端进行数据的插入和删除的线性存储结构。增栈 减栈：用栈顶的增长方向区分（移动方向）顺序队列：假溢出------>循环队列。满栈 空栈：栈顶所在位置是否存有元素。增栈：从内存低地址向高地址移动。减栈：从内存高地址向低地址移动。链式队列：用链表方式构造队列。
Redis常见的数据结构
weixin_61669379的博客
09-09 1007
Redis底层的数据结构是Redis高效存储和操作数据的基础,Redis提供了五种基本的数据类型，每种类型在底层都有对应的数据结构来实现。这五种数据类型分别是：字符串（String）、哈希（Hash）、列表（List）、集合（Set）和有序集合（Sorted Set）。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值