数据结构——带头结点的双链表增删查改的C语言实现

最新推荐文章于 2023-01-27 16:20:43 发布
最新推荐文章于 2023-01-27 16:20:43 发布
阅读量137 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46657980/article/details/107592236
版权

1、dclist.h

#ifndef _dclist_h_
#define _dclist_h_

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
#include<memory.h>
#include<vld.h>  
#pragma warning(disable:4996)
#define ElemType int
typedef struct DCListNode
{
	ElemType data;
	struct DCListNode *next;
	struct DCListNode *prev;
}DCListNode;
typedef DCListNode *DCList;

void DCListInit(DCList *phead);
void DCListPushBack(DCList *phead, ElemType x);
void DCListPushFront(DCList *phead, ElemType x);
void DCListShow(DCList phead);
void DCListPopBack(DCList *phead);
void DCListPopFront(DCList *phead);
bool DCListInsertVal(DCList phead, ElemType x);
void DCListEraseVal(DCList phead, ElemType x);
DCListNode* DCListFind(DCList phead, ElemType x);
size_t DCListLength(DCList phead);
void DCListSort(DCList phead);
void DCListReverse(DCList phead);
void DCListClear(DCList *phead);
ElemType DCListFront(DCList phead);
ElemType DCListBack(DCList phead);
void DCListDestroy(DCList *phead);
#endif

（1）初始化

DCListNode* _Buynode()
{
	DCListNode *_S = (DCListNode*)malloc(sizeof(DCListNode));
	assert(_S != NULL);
	_S->next = _S->prev = _S;
	return _S;
}
void DCListInit(DCList *phead)
{
	assert(phead != NULL);
	*phead = _Buynode();
}

（2） 尾插、头插

void DCListPushBack(DCList *phead, ElemType x)
{
	assert(phead != NULL);
	DCListNode *s = (DCListNode *)malloc(sizeof(DCListNode));
	DCListNode *p = *phead;
	assert(s != NULL);
	s->data = x;
	s->prev = p->prev;
	s->next = p;
	p->prev->next = s;
	p->prev = s;
}
void DCListPushFront(DCList *phead, ElemType x)
{
	assert(phead != NULL);
	DCListNode *s = (DCListNode *)malloc(sizeof(DCListNode));
	DCListNode *p = *phead;
	assert(s != NULL);
	s->data = x;
	s->prev = p;
	s->next = p->next;
	s->prev->next = s;
	s->prev->next = s;
}

（3）链表打印

void DCListShow(DCList phead)
{
	assert(phead != NULL);
	DCListNode *p = phead->next;
	while (p != phead)
	{
		printf("%d->", p->data);
		p = p->next;
	}
	printf("Over.\n");
}

 （4）尾删、头删

void DCListPopBack(DCList *phead)
{
	assert(phead != NULL);
	DCListNode *p = *phead;
	if (p->next == p)
	{
		printf("链表已空，删除失败！\n");
		return;
	}
	DCListNode *s = p->prev;
	s->prev->next = p;
	p->prev = s->prev;
	free(s);
}
void DCListPopFront(DCList *phead)
{
	assert(phead != NULL);
	DCListNode *p = *phead;
	if (p->next == p)
	{
		printf("链表已空，删除失败！\n");
		return;
	}
	DCListNode *s = p->next;
	s->next->prev = p;
	s->prev->next = s->next;
	free(s);
}

（5）按值插入、删除

bool DCListInsertVal(DCList phead, ElemType x)
{
	assert(phead != NULL);
	DCListNode *p = phead->next;
	while (p != phead && x > p->data)
		p = p->next;
	DCListNode* s = (DCListNode*)malloc(sizeof(DCListNode));
	assert(s != NULL);
	s->data = x;
	s->prev = p->prev;
	s->next = p;
	s->prev->next = s;
	s->next->prev = s;
}
void DCListEraseVal(DCList phead, ElemType x)
{
	assert(phead != NULL);
	DCListNode *p = DCListFind(phead, x);
	if (p == NULL)
		return;
	p->prev->prev = p->next;
	p->next->prev = p->prev;
	free(p);
}

 （6）查找

DCListNode* DCListFind(DCList phead, ElemType x)
{
	assert(phead != NULL);
	DCListNode *p = phead->next;
	while (p != phead && p->data != x)
		p = p->next;
	if (p == phead)
		return;
	return p;
}

（7）求长度

size_t DCListLength(DCList phead)
{
	assert(phead != NULL);
	DCListNode *p = phead->next;
	size_t len = 0;
	while (p != phead)
	{
		len++;
		p = p->next;
	}
	return len;
}

 （8）排序

void DCListSort(DCList phead)
{
	assert(phead != NULL);
	if (DCListLength(phead) == 1)
	{
		return;
	}
	DCListNode *p = phead->next;
	DCListNode *q = p->next;
	p->next = phead;
	phead->prev = p;
	while (q != phead)
	{
		p = q;
		q = q->next;
		DCListNode *tmp = phead->next;
		while (tmp != phead && p->data > tmp->data)
			tmp = tmp->next;
		p->next = tmp;
		p->prev = tmp->prev;
		p->next->prev = p;
		p->prev->next = p;
	}
}

（9）逆置

void DCListReverse(DCList phead)
{
	assert(phead != NULL);
	if (DCListLength(phead) == 1)
	{
		return;
	}
	DCListNode *p = phead->next;
	DCListNode *q = p->next;
	p->next = phead;
	phead->prev = p;
	while (q != phead)
	{
		p = q;
		q = q->next;
		p->next = phead->next;
		p->prev = phead;
		p->next->prev = p;
		p->prev->next = p;
	}
}

（10）清空

void DCListClear(DCList *phead)
{
	assert(phead != NULL);
	DCListNode *p = (*phead)->next;
	while (p != *phead)
	{
		p->prev->next = p->next;
		p->next->prev = p->prev;
		free(p);
		p = (*phead)->next;
	}
}

（11）取头元素、尾元素

ElemType DCListFront(DCList phead)
{
	assert(phead != NULL);
	assert(phead->next != phead);
	return phead->next->data;
}
ElemType DCListBack(DCList phead)
{
	assert(phead != NULL);
	assert(phead->next != phead);
	return phead->prev->data;
}

（12）摧毁

void DCListDestroy(DCList *phead)
{
	assert(phead != NULL);
	DCListClear(phead);
	free(*phead);
	*phead = NULL;
}

2、dclist.c

#include"dclist.h"

int main()
{
	DCList list;
	DCListInit(&list);
	DCListNode *p = NULL;
	ElemType item;
	int pos;
	bool flag;
	int select = 1;
	while (select)
	{
		printf("***************************************\n");
		printf("* [1] push_back       [2] push_front  *\n");
		printf("* [3] show_list       [0] quit_system *\n");
		printf("* [4] pop_back        [5] pop_front   *\n");
		printf("* [6] insert_val      [7] erase_val   *\n");
		printf("* [8] find            [9] length      *\n");
		printf("* [10] sort           [11] reverse    *\n");
		printf("* [12] clear          [13] front      *\n");
		printf("* [14] back           [15] destroy    *\n");
		printf("***************************************\n");
		printf("请选择:>");
		scanf("%d", &select);
		if (select == 0)
		{
			break;
		}
		switch (select)
		{
		case 1:
			printf("请输入要插入的数据<以-1结束>:");
			while (scanf("%d", &item), item != -1)
			{
				DCListPushBack(&list, item);
			}
			printf("尾部插入数据成功！\n");
			break;
		case 2:
			printf("请输入要插入的数据<以-1结束>:");
			while (scanf("%d", &item), item != -1)
			{
				DCListPushFront(&list, item);
			}
			printf("头部插入数据成功！\n");
			break;
		case 3:
			DCListShow(list);
			break;
		case 4:
			DCListPopBack(&list);
			printf("尾部删除数据成功！\n");
			break;
		case 5:
			DCListPopFront(&list);
			printf("头部删除数据成功！\n");
			break;
		case 6:
			printf("请输入要插入的元素：");
			scanf("%d", &item);
			DCListSort(&list);
			DCListInsertVal(list, item);
			flag = DCListInsertVal(&list, item);
			if (flag)
			{
				printf("插入数据成功！\n");
			}
			else
			{
				printf("插入数据失败！\n");
			}
			break;
		case 7:
			printf("请输入要删除的元素：");
			scanf("%d", &item);
			DCListEraseVal(list, item);
			printf("删除元素成功！\n");
			break;
		case 8:
			printf("请输入要查找的元素：");
			scanf("%d", &item);
			DCListFind(list, item);
			break;
		case 9:
			printf("SeqList length=%d\n", DCListLength(list));
			break;
		case 10:
			DCListSort(list);
			printf("顺序表排序成功！\n");
			break;
		case 11:
			DCListReverse(list);
			printf("顺序表转置完成！\n");
			break;
		case 12:
			DCListClear(&list);
			break;
		case 13:
			printf("表头元素为%d\n", DCListFront(list));
			break;
		case 14:
			printf("表尾元素为%d\n", DCListBack(list));
			break;
		case 15:
			DCListDestroy(&list);
			printf("摧毁成功！\n");
			break;
		default:
			printf("输入错误，请重新选择.......\n");
			break;
		}
		system("pause");
		system("cls");
	}
	return 0;
}

 

@余笙！
关注
数据结构——带头结点链表和不带头结点链表操作比较
Floating Cat
11-26 2379
带头结点的链表和不带头结点的链表主要不同点在插入和删除操作上。同时要注意，带头结点的链表初始化操作时建立头结点。 下面我们来看一下代码中的异同： #include #include #include typedef int elemType; typedef struct Node{//定义链接节点 elemType element; Node* next; }Node; int in
数据结构————带头结点单链表讲解
m0_64985004的博客
03-13 1936
单链表分为带头结点的和不带头结点的，两者的根本区别在于是否有不存储元素的头结点。头结点的存在可以让链表为空的时候不销毁，操作也更方便，不用附带二级指针。 表示形式 每一个结点都有指针域和数据域，指针域用来指向下一个结点，数据域用来存放该结点的元素。 基本操作 单链表的基本操作有初始化、前插、后插、前删、后删等。后面我们将讲述基于这些基本操作上更复杂的操作。 1.初始化 2.前插 3.后插 4.前删 5.后删 6.插入 7.删除 ...
C语言实现双链表(带头节点)
weixin_34318326的博客
07-31 268
双链表和单链表性质相似只是在多加了一个前指针 1.定义结构体 typedef struct Node{ int data; struct Node *prior; struct Node *next; }Node,*LinkedList; 2.比单链表一个指向 LNew->data = i; L->next = LNew; LNew->...
数据结构---带头结点的双向链表的增删查改1（C语言实现）
Devil_Net的博客
04-08 418
实现环境：LINUX带头结点的增删查改相对而言比较简单，但是里边还是有些许坑，，稍不注意就掉进去，半天爬不出来。                                                   将要实现的链表的图：在双向链表中需要注意的是要注意两组指针的指向，即next和prev对应。双向链表已经可以说完成一半了。在一个需要注意的坑是，在插入的时候需要注意的是一定要先new与n...
数据结构：试设计一个算法，改造一个带表头结点的双向链表，所有结点的原有次序保持在各个结点的右链域rLink中，并利用左链域ILink把所有结点按照其值从小到大的顺序连接起来
热门推荐
寒泉
10-29 6万+
题目 试设计一个算法，改造一个带表头结点的双向链表，所有结点的原有次序保持在各个结点的右链域rLink中，并利用左链域ILink把所有结点按照其值从小到大的顺序连接起来 分析 Template <Type> void DblList<Type>::sort() { DblNode <Type> *pre, *ppre; // pre用于记录p的前驱 DblNode <Type> *s = first->rLink; // s指向待插
数据结构单链表的增删查改（c语言实现）
qq_43759329的博客
12-17 582
1、单链表 typedef int SLTDataType; typedef struct SListNode { SLTDataType data; // val struct SListNode* next; }SListNode; 2、动态申请一个节点
设计一个带表头的双向链表（略有修改
m0_55971510的博客
05-11 216
设计一个带表头的双向链表，要求链表中可以存放 任意类型的数据 ），提供以下方法：（1）insert： 在某个位置 插入对象；（2）insert：在链表的最后插入对象；（2）delete：在某个位置删除对象；（3）delete：删除链表中与x相同的元素；（4）size：返回当前链表中对象的个数；（5）isEmpty：判断链表是否为空；（6）traverse：遍历链表，打印出所有的元素；（7）getData：取得某个位置的对象。构造main函数进行测试。 package list; public class
C语言实现带头结点的链表的创建、查找、插入、删除操作
01-20
本文实例讲述了C语言实现带头结点的链表的创建、查找、插入、删除操作。是数据结构中链表部分的基础操作。分享给大家供大家参考。具体方法如下： #include #include typedef struct node { int data; struct ...
C语言实现数据结构和双向链表操作
08-31
C语言实现数据结构和双向链表操作 本文主要介绍了C语言实现数据结构双向链表操作的相关知识点。双向链表是一种常用的数据结构，它可以从两个方向搜索某个结点，且可以从头结点和尾结点进行遍历。 1. 双向链表的...
链表-使用C语言实现带头结点的单链表.zip
最新发布
03-13
本资料包"链表-使用C语言实现带头结点的单链表.zip"详细介绍了如何用C语言构建一个带头结点的单链表。 首先，我们来看链表的基本概念。链表由一系列节点组成，每个节点包含两部分：数据元素和指向下一个节点的指针...
改造一个双向循环链表，使右链域保持原来的顺序，而左链域从小到大顺序排列。
weixin_41546300的博客
10-21 1546
// 这道题的算法是我自己编写而来的，我也是一名学生，如果有什么更好的方法，我们可以相互交流。 在我的算法中，我使用了一个宏定义MaxNum 表示最大的数，实现了对左链域从小到大排列。实现从大到小排列只需要把MaxNum改成Minmun即可。也是本算法最大的一个优点。好，话不多说，现在我来说一下自己的思想。 先将所有结点的左指针全部清空。 定义3个指针，p(查找指针)，q...
【数据结构和算法】实现带头双向循环链表（最复杂的链表）
小王学代码
01-27 1164
我们本文主要讲解了，链表中最为复杂的带头双向循环链表的使用和代码实现，实现了头插尾插，头删尾删，初始化、打印、指定pos位置插入结点或者删除结点、寻找结点、摧毁链表等函数。并做了板书图示解释相应函数的流程，附带完整代码，以便帮助大家更好的理解。
19 计学
weixin_43911559的博客
10-04 436
1.试设计一个算法，改造一个带表头结点的双向链表，所有结点的原有次序保持在各个结点的右链域rLink中，并利用左链域ILink把所有结点按照其值从大到小的顺序连接起来 思路：类似尾插法。先把所有结点的前驱指针全部断掉，然后根据后继指针遍历整个链表，每一轮找到一个最小的结点，然后把这个结点的前驱指针指向左链域的尾指针。最后所有结点的前驱指针都已连接，算法结束。因为左链域的指向是从右到左，所以从大到小链接的话，最小值的前驱应该是头结点。 #define Min 1000 typedef struct node
南理工ds期末以及824真题算法汇总
weixin_45312990的博客
12-11 1150
南理工ds期末以及824真题算法汇总 单链表 设有线性表L={a1, a2, …, an}，顺序存储，试写一个算法将线性表的元素按照原始顺序构造一个有头结点的单链表 基本思想: 遍历线性表L，采用尾插法建立单链表(如果逆序，则用头插法) typedef struct{ ElemType *elem; int length; int listSize; }Sqlist; typed...
C语言数据结构之链表的增删改查
wrlovesmile的博客
08-10 5284
C语言数据结构之链表的增删改查 tips:昨天学习了c语言结构体，今天来看看c语言数据结构之链表的增删改查操作 首先我们创建一个简单的学生信息结构体，作为后面增删改查的主体 student结构体包含 数据域：学号，分数； 指针域：一个指向后继结点的pNext指针； typedef struct student { int num; int score; struct student *pNext; }stu, *pstu; 链表测试输出函数 //链表打印 void lis
剑指offer链表添加，删除元素中传入的pHead为什么要是指向头指针的指针问题
jmt330的博客
05-02 2018
总结来说，是因为当增删的元素位置在链表首位时，如果传入的实参是头指针，相当于是把实参指向的结构的位置传入进来，让形参指向这个位置，那么当形参的指针指向发生变化时，最终实参还是指向它原来指向的位置。 顺便想想为什么在变化的节点不位于首位时，传入头指针是没问题的呢？因为形参指针与实参指针开始时指向同一位置，之后操作时，形参指针向后遍历，改变的是实参指向的链表的结构，因此当操作完成后，并不需要改变实参
数据结构（C语言） 单链表基础 增删改查
weixin_43903312的博客
04-16 2008
数据结构这门课是每个程序员都必须要熟悉掌握的一门课程,更何况绩点还是得要的 而且这门课讲的知识很多而且会用到c语言程序设计中较为复杂的东西，不及时再将实例亲自打一遍是不行的，此博客将总结数据结构中所讲的单链表最基本的增删改查的操作方法，以便于之后栈与队列的学习。 一. 什么是单链表？ 单向链表（又名单链表、线性链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过从头部开始，依序...
【数据结构】线性表（二）：链表 之 单向非循环链表
宫瑞阳的博客
07-22 521
单向非循环链表的基本概念+基本操作+代码实现
【C】利用单链表数据结构实现通讯录，链表的增删改查
编程记录，亲测有效
08-07 1万+
C语言中实现链表，是需要利用到C语言中比较难的结构体与指针才能实现。 结构体中放一个指向后接节点的指针与每一个结点应该存放的信息。 下面做一个命令行的通讯录来说明链表的增删改查这个问题。 一开始让用户输入链表，按1可以输出，按3可以删除。 可以修改： 可以插入。 按0则可以退出： 代码如下： #include #include typedef str
链表数据结构详解与增删查改实现教程
资源摘要信息:"数据结构顺序表和链表（超详细）" ...理解链表的增删查改操作对于掌握数据结构与算法的实现至关重要。通过文件中提及的压缩包中的实践代码，可以加深对链表操作的理解，并在实际开发中灵活应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值