双链表实现--C语言版

最新推荐文章于 2022-11-20 15:00:23 发布
最新推荐文章于 2022-11-20 15:00:23 发布
阅读量107 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 链表 c语言 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/COOL_jack/article/details/118615526
版权

目录

声明

以下内容仅供学习，如有侵权，联系作者删除。
参考文献：王道考研系列数据结构、B站up主：C语言技术网
链接: C语言技术网.

代码实现：

/*
 * 程序名：linklist4.c，此程序演示带头结点的双链表的实现，数据元素是整数。
 * 作者：jack 日期：20210710
 * 参考作者：C语言技术网(www.freecplus.net), B站UP主：C语言技术网
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef int ElemType;	// 自定义链表的数据元素为整数。

typedef struct DNode
{
	ElemType data;	// 存放结点的数据元素。
	struct DNode *prev,*next;	// 前驱和后继结点的指针。
}DNode, *DLinkList;

// 初始化链表DL，返回值：失败返回NULL，成功返回头结点的地址。
DNode *InitDList1();

// 清空链表DL
void ClearDList(DLinkList DL);

// 销毁链表DL。
void DestroyDList1(DLinkList DL);

// 在链表DL的第ii个位置插入元素ee，返回值：0-失败；1-成功。
int  InsertDList(DLinkList DL, unsigned int ii, ElemType *ee);

// 在链表LL的头部插入元素ee，返回值：0-失败；1-成功。
int  PushFront(DLinkList DL, ElemType *ee);

// 在链表LL的尾部插入元素ee，返回值：0-失败；1-成功。
int PushBack(DLinkList DL, ElemType *ee);

// 在指定结点pp之后插入元素ee，返回值：0-失败；1-成功。
int InsertNextNode(DNode *pp, ElemType *ee);

// 在指定结点pp之前插入元素ee，返回值：0-失败；1-成功。
int InsertPriorNode(DNode *pp, ElemType *ee);

// 删除链表DL中的第ii个结点，返回值：0-位置ii不合法；1-成功。
int  DeleteNode(DLinkList DL, unsigned int ii);

// 删除链表DL中第一个结点，返回值：0-位置不合法；1-成功。
int PopFront(DLinkList DL);

// 删除链表LL中最后一个结点，返回值：0-位置不合法；1-成功。
int PopBack(DLinkList DL);

// 删除指定结点。
int DeleteNode1(DNode *pp);

// 查找元素ee在链表DL中的结点地址，如果没找到返回NULL，否则返回结点的地址。
DNode *LocateElem(DLinkList DL, ElemType *ee);

// 获取链表中第ii个结点，成功返回结点的地址，失败返回空。
// 注意，ii可以取值为0，表示头结点。
DNode *LocateNode(DLinkList DL, unsigned int ii);

// 打印链表中全部的元素。
void PrintDList(DLinkList DL);

// 求链表的长度，返回值：>=0-表LL结点的个数。
int  LengthDList(DLinkList DL);

// 判断链表是否为空，返回值：0-非空或失败，1-空。
int IsEmpty(DLinkList DL);

int main()
{
	DLinkList DL = NULL; // 声明链表指针变量。

	DL = InitDList1();     // 初始化链表。

	printf("DL=%p\n", DL);

	ElemType ee;      // 创建一个数据元素。

	printf("在表中插入元素（1、2、3、4、5、6、7、8、9、10）。\n");
	ee = 1;  InsertDList(DL, 1, &ee);
	ee = 2;  InsertDList(DL, 1, &ee);
	ee = 3;  InsertDList(DL, 1, &ee);
	ee = 4;  InsertDList(DL, 1, &ee);
	ee = 5;  InsertDList(DL, 1, &ee);
	ee = 6;  InsertDList(DL, 1, &ee);
	ee = 7;  InsertDList(DL, 1, &ee);
	ee = 8;  InsertDList(DL, 1, &ee);
	ee = 9;  InsertDList(DL, 1, &ee);
	ee = 10; InsertDList(DL, 1, &ee);

	printf("length=%d\n", LengthDList(DL));	PrintDList(DL);

	printf("\n");
	printf("演示按位置插入元素。\n");
	printf("在第5个位置插入元素（13）。\n");
	ee = 13; InsertDList(DL, 5, &ee);	PrintDList(DL);

	printf("在表头插入元素（66），表尾插入元素（99）。\n");
	ee = 66; PushFront(DL, &ee);
	ee = 99; PushBack(DL, &ee);	PrintDList(DL);

	printf("\n");
	printf("演示按位置删除元素。\n");
	printf("删除表中第7个结点。\n");
	DeleteNode(DL, 7); PrintDList(DL);

	printf("删除表中第一个结点。\n");
	PopFront(DL); PrintDList(DL);

	printf("删除表中最后一个结点。\n");
	PopBack(DL); PrintDList(DL);

	printf("\n");
	printf("演示查找元素。\n");
	DNode *tmp;

	if ((tmp = LocateNode(DL, 3)) != NULL)
		printf("第3个结点的地址是=%p，ee=%d\n", tmp, tmp->data);
	else
		printf("元素值为8的结点的地址是NULL，没找着。\n");

	printf("\n");
	printf("演示按节点插入元素。\n");
	printf("在结点%p之后插入88\n", tmp);
	ee = 88;
	InsertNextNode(tmp, &ee);  PrintDList(DL);

	printf("在结点%p之前插入77\n", tmp);
	ee = 77;
	InsertPriorNode(tmp, &ee);  PrintDList(DL);

	printf("\n");
	printf("演示按节点删除元素。\n");
	// 找到第10个节点并删除它。
	if ((tmp = LocateNode(DL, 10)) != NULL)
		printf("第10个结点的地址是=%p，ee=%d\n", tmp, tmp->data);

	printf("删除结点%p\n", tmp);
	DeleteNode1(tmp);	PrintDList(DL);

	printf("\n");
	printf("演示销毁链表。\n");
	DestroyDList1(DL); DL = NULL;  // 销毁链表，LL置为空。
	printf("DL=%p\n", DL);

	return 0;
}

// 初始化链表DL，返回值：失败返回NULL，成功返回头结点的地址。
DNode *InitDList1()
{
	DNode *head = (DNode *)malloc(sizeof(DNode));	// 分配头结点。
	if (head == NULL)	return NULL;	// 内存不足，返回失败。

	head->next = head->prev = NULL;	// 前驱后继结点都置为空。

	return head;
}

void ClearDList(DLinkList DL)
{
	// 清空链表DL是指释放链表全部的结点，但不包括头结点。
	if (DL == NULL) { printf("链表LL不存在。\n"); return; } // 判断链表是否存在。

	DNode *tmp1;
	DNode *tmp2 = DL->next;	// 保留头结点，从头结点的下一个结点开始释放。

	while (tmp2 != NULL)
	{
		tmp1 = tmp2->next;
		free(tmp2);
		tmp2 = tmp1;
	}

	DL->next = NULL;	// 这行代码一定不能少，否则会留下野指针。
}

// 销毁链表DL。
void DestroyDList1(DLinkList DL)
{
	if (DL == NULL) { printf("链表LL不存在。\n"); return; } // 判断链表是否存在。

	DNode *tmp1;	// 销毁链表LL是指释放链表全部的结点，包括头结点。

	while (DL != NULL)
	{
		tmp1 = DL->next;
		free(DL);
		DL = tmp1;
	}
	// LL=NULL;   // LL在本函数中相当于局部变量，就算置空了也不会影响调用者传递的LL，
				  // 所以LL=NULL没有意义。
}

// 在链表DL的第ii个位置插入元素ee，返回值：0-失败；1-成功。
int  InsertDList(DLinkList DL, unsigned int ii, ElemType *ee)
{
	if ((DL == NULL) || (ee == NULL)) { printf("链表LL或元素ee不存在。\n"); return 0; } // 判断表和元素是否存在。

	// 判断插入位置是否合法
	if (ii < 1) { printf("插入位置（%d）不合法，应该在大于0。\n", ii); return 0; }

	// 要在位序ii插入结点，必须找到ii-1结点。
	DNode *pp = DL;  // 指针pp指向头结点，逐步往后移动，如果为空，表示后面没结点了。
	int kk = 0;      // kk指向的是第几个结点，从头结点0开始，pp每向后移动一次，kk就加1。

	while ((pp != NULL) && (kk < ii-1))
	{
		pp = pp->next;	kk++;
	}

	if (pp == NULL) { printf("位置（%d）不合法，超过了表长。\n", ii); return 0; }

	DNode *tmp = (DNode *)malloc(sizeof(DNode));	// 分配一个结点。
	if (tmp == NULL)	return 0;	// 内存不足，返回失败。

	// 考虑数据元素为结构体的情况，这里采用了memcpy的方法而不是直接赋值。
	memcpy(&tmp->data, ee, sizeof(ElemType));

	// 处理前驱后续结点的指针。
	tmp->next = pp->next;
	tmp->prev = pp;

	pp->next = tmp;
	if (tmp->next != NULL) tmp->next->prev = tmp;  // 特殊处理，如果是在尾部插入，tmp->next根本不存在。

	return 1;

	///
	// 以上代码可以用以下代码代替。
	// DNode *pp=LocateNode(LL,ii-1);  
	// return InsertNextNode(pp,ee);
	///
}

// 在链表LL的头部插入元素ee，返回值：0-失败；1-成功。
int  PushFront(DLinkList DL, ElemType *ee)
{
	return InsertDList(DL, 1, ee);
}

// 在链表LL的尾部插入元素ee，返回值：0-失败；1-成功。
int PushBack(DLinkList DL, ElemType *ee)
{
	DNode *pp = DL;	// 从头结点开始。

	while (pp->next != NULL)
	{
		pp = pp->next;
	}

	DNode *tmp = (DNode *)malloc(sizeof(DNode));	// 分配一个结点。
	if (tmp == NULL)	return 0;	// 内存不足，返回失败。

	// 考虑数据元素为结构体的情况，这里采用了memcpy的方法而不是直接赋值。
	memcpy(&tmp->data, ee, sizeof(ElemType));

	// 处理前驱后续结点的指针。
	tmp->next = pp->next;
	tmp->prev = pp;

	pp->next = tmp;

	return 1;
}

// 在指定结点pp之后插入元素ee，返回值：0-失败；1-成功。
int InsertNextNode(DNode *pp, ElemType *ee)
{
	if (pp == NULL) { printf("结点pp不存在。\n"); return 0; }

	DNode *tmp = (DNode *)malloc(sizeof(DNode));
	if (tmp == NULL)	return 0;

	memcpy(&tmp->data, ee, sizeof(ElemType));

	// 处理前驱后续结点的指针。
	tmp->next = pp->next;
	tmp->prev = pp;
	pp->next = tmp;
	if (tmp->next != NULL)	tmp->next->prev = tmp;	// 特殊处理，如果是在尾部插入，tmp->next根本不存在。

	return 1;
}

// 在指定结点pp之前插入元素ee，返回值：0-失败；1-成功。
int InsertPriorNode(DNode *pp, ElemType *ee)
{
	if (pp == NULL) { printf("结点pp不存在。\n"); return 0; }

	// 在单链表中，如果要在指定结点pp之前插入元素，采用的是偷梁换柱的方法。
	// 在双链表中，偷不偷都行，因为pp->prior有前驱结点的地址。

	DNode *tmp = (DNode *)malloc(sizeof(DNode));
	if (tmp == NULL) return 0;

	// 把待插入的元素存入tmp中。
	memcpy(&tmp->data, ee, sizeof(ElemType));

	// 处理前驱后继指针。
	tmp->prev = pp->prev;
	pp->prev->next = tmp;

	tmp->next = pp;
	pp->prev = tmp;

	return 1;
}

// 删除链表DL中的第ii个结点，返回值：0-位置ii不合法；1-成功。
int  DeleteNode(DLinkList DL, unsigned int ii)
{
	if (DL == NULL) { printf("链表LL不存在。\n"); return 0; } // 判断链表是否存在。

	// 判断删除位置是否合法
	if (ii < 1) { printf("删除位置（%d）不合法，应该在大于0。\n", ii); return 0; }

	DNode *pp = DL;
	int kk = 0;

	while ((pp != NULL) && (kk < ii - 1))
	{
		pp = pp->next;	kk++;
	}

	// 注意，以下行的代码与视频中的不一样，视频中的是 if ( pp==NULL )，有bug。
	if (pp->next == NULL) { printf("位置（%d）不合法，超过了表长。\n", ii); return 0; }

	DNode *tmp = pp->next;	// tmp为将要删除的结点。

	// 处理前驱后续结点的指针。
	pp->next = tmp->next;
	if (tmp->next != NULL) tmp->next->prev = pp; // 特殊处理，如果tmp是尾结点，tmp->next根本不存在。

	free(tmp);

	return 1;
}

// 删除链表DL中第一个结点，返回值：0-位置不合法；1-成功。
int PopFront(DLinkList DL)
{
	return DeleteNode(DL, 1);
}

// 删除链表LL中最后一个结点，返回值：0-位置不合法；1-成功。
int PopBack(DLinkList DL)
{
	if (DL == NULL) { printf("链表DL不存在。\n"); return 0; } // 判断表和元素是否存在。

  // 必须加上这个判断，不要误删了头结点。
	if (DL->next == NULL) { printf("链表LL为空，没有尾结点。\n"); return 0; } // 判断表是否为空。

	DNode *pp = DL;  // 从第0个结点开始。

  // 找到最后一个结点。
	while (pp->next != NULL) pp = pp->next;

	pp->prev->next = NULL;  // 把最后一个节点的前一结点的next指针置为空。

	// 释放最后一个结点。
	free(pp);

	return 1;
}

// 删除指定结点。
int DeleteNode1(DNode *pp)
{
	// 在单链表中，删除指定结点根本不可行，也不能采用偷梁换柱的方法。
	// 但是，在双链表中，删除指定结点是可行的。

	pp->prev->next = pp->next;
	if (pp->next != NULL)	pp->next->prev = pp->prev;	// 特殊处理，如果pp是尾结点，pp->next->prior根本不存在。

	free(pp);

	return 1;
}

// 查找元素ee在链表DL中的结点地址，如果没找到返回NULL，否则返回结点的地址。
DNode *LocateElem(DLinkList DL, ElemType *ee)
{
	DNode *pp = DL->next;

	while (pp)
	{
		// 如果数据元素是结构体，以下代码要修改。
		if (*ee == pp->data)	return pp;
		pp = pp->next;
	}

	return NULL;
}

// 获取链表中第ii个结点，成功返回结点的地址，失败返回空。
// 注意，ii可以取值为0，表示头结点。
DNode *LocateNode(DLinkList DL, unsigned int ii)
{
	if (DL == NULL) { printf("链表DL不存在。\n"); return NULL; } // 判断表和元素是否存在。

	DNode *pp = DL;
	int kk = 0;
	while ((pp != NULL) && (kk < ii))
	{
		pp = pp->next;	kk++;
	}

	if (pp == NULL) { printf("位置（%d）不合法，超过了表长。\n", ii); return NULL; }

	return pp;
}
// 打印链表中全部的元素。
void PrintDList(DLinkList DL)
{
	if (DL == NULL) { printf("链表DL不存在。\n"); return; } // 判断链表是否存在。

	DNode *pp = DL->next;  // 从第1个结点开始。

	while (pp != NULL)
	{
		printf("%-3d", pp->data);  // 如果元素ee为结构体，这行代码要修改。
		pp = pp->next;
	}

	printf("\n");

	/*
	  // 以下代码用于显示全部结点的地址和元素的值。
	  DNode *pp=DL;  // 从第0个结点开始。

	  while (pp != NULL)
	  {
		printf("pp=%p,prior=%p,next=%p,data=%-3d\n",pp,pp->prior,pp->next,pp->data);
		pp=pp->next;
	  }
	*/
}

// 判断链表是否为空，返回值：0-非空或失败，1-空。
int IsEmpty(DLinkList DL)
{
	if (DL == NULL) return 0;

	if (DL->next == NULL) return 1;

	return 0;
}

// 求链表的长度，返回值：>=0-表LL结点的个数。
int  LengthDList(DLinkList DL)
{
	if (DL == NULL) { printf("链表DL不存在。\n"); return 0; } // 判断链表是否存在。

	DNode *pp = DL->next;  // 头结点不算，从第1个结点开始。

	int length = 0;

	while (pp != NULL) { pp = pp->next; length++; }

	return length;

	// 不使用临时变量，如何计算链表（包括头结点）的长度？
	// if (LL==NULL) return 0;
	// return LengthList(LL->next)+1;
}

运行结果：
在这里插入图片描述

jack学编程
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构学习笔记（三）| 1 线性表 之 链表
Daniel960的博客
06-24 163
链表 单链表 双链表 循环链表 静态链表
数据结构笔记 六：双链表
OnlyLove_的博客
10-14 338
说明：本笔记依照《王道论坛-数据结构》视频内容整理。 单链表：无法逆向检索，有时候不太方方便。 双链表：可进可退，存储密度更低一点。 一、双链表结点 typedef int ElemType; // 根据实际情况定义 typedef struct lNode{ // 定义单列表结点类型 ElemType data; // 每个结点存放一个数据元素 struct lNode *prior,*next; // prior指向前驱结点，
单链表（带头结点）——建立、查找、插入、删除、销毁等操作的代码实现（王道版）
a1833235073的博客
07-23 1404
单链表（带头结点）建立、查找、插入、删除、销毁等操作的代码实现（王道版）
C++ 单链表（无头结点）
qq_43650934的博客
11-17 4977
文章目录总结归纳代码实现 总结归纳 头结点可以没有，头指针必须有。访问整个链表，是用过遍历头指针来进行的。 这里没有特别的设置一个头指针，因为当指针指向整个链表 L 时，该指针的实现效果就是头指针。 不带头结点的单链表，即单链表的第一个结点就存储数据，头指针也指向第一个结点；带头结点的单链表，第一个结点是头结点，不存储数据，从头结点的 next 开始存储，头指针可以从头结点的 next 开始遍历。 对于结点的前插操作，找到对应位置的结点，设新结点为该节点的后继结点，将该结点的 data 后移至新结点的 d
单链表的基本操作
weixin_64084604的博客
11-20 2904
单链表基本操作
双向链表实现贪吃蛇游戏（C语言版）
12-26
在本文中，我们将深入探讨如何使用C语言和双向链表实现经典的贪吃蛇游戏。双向链表是一种数据结构，它允许我们在列表中的任何位置轻松地插入和删除元素，这使得它成为实现动态游戏世界，如贪吃蛇，的理想选择。 1. ...
双向循环链表-C语言实现.doc
09-21
这篇文档主要介绍的是如何在C语言中实现双向循环链表的操作。双向循环链表是一种特殊的数据结构，每个节点不仅包含数据，还包含指向左邻节点和右邻节点的指针，形成一个首尾相连的环状结构。 首先，定义了一个名为`...
链表-基于C语言实现的双向链表.zip
最新发布
06-28
链表 链表_基于C语言实现的双向链表
链表-使用C语言实现非循环双向链表-带头结点+尾结点.zip
03-13
在C语言中实现链表可以帮助我们更好地理解数据结构的底层运作，并且能够灵活地进行各种操作。本篇将详细介绍如何使用C语言来实现一个非循环双向链表，包括带头结点和尾结点的链表。 首先，让我们定义链表节点的数据...
双向链表API及C语言实现
03-29
双向链表的API和C语言实现，程序说明在我的专栏《数据结构与算法学习笔记》中双向链表相关文章。包含了双向链表的结点结构体、表头结构体、创建双向链表、销毁双向链表、获取链表长度、清空双向链表、插入一个节点...
单链表的基础操作(带头结点)
gaokuiyuan的博客
07-23 2919
数据结构带头结点的基础操作单链表的接口化输出（带main函数和实现过程哦）
数据结构-单链表的两种实现方式
ytuyzh的博客
03-22 536
单链表的两种实现方式：带头结点和不带头结点 需要注意的地方： 1、带头结点和不带头结点在实现插入和删除操作时的区别 2、封装的方便之处（见InsertPriorNode(LNode *p,ElemType e)），能够使代码更简洁，更加清晰 3、带头结点方式中，头结点不装入数据，并且看作成第0个结点。不带头结点方式，没有头结点，从第1个结点开始。 4、注意一些特判情况 例如： 按位序...
线性表-单链表(Ⅲ)
Miss Z的博客
07-26 514
数据结构-线性表(第二章)的整理笔记，若有错误，欢迎指正。 线性表-顺序表(Ⅱ) 线性表的链式表示 单链表的定义 线性表的链式存储又称单链表，它是指通过一组任意的存储单元来存储线性表中的数据元素。为了建立数据元素之间的线性关系，对每个链表结点，除存放元素自身的信息外，还需要存放一个指向其后继的指针。 单链表中结点类型的描述为： typedef struct LNode { ElemeType data; //数据域 struct Lnode *next; //指针域 }LNode, * Lin
数据结构学习：单链表的基本操作之插入与删除
weixin_45632016的博客
07-24 2662
单链表的基本操作 单链表的基本操作之插入 ListInsert(&L,i,e)：插入操作。在表L中的第i个位置上插入指定元素e。 即将插入位置的前一个节点的指针指向插入节点，插入节点的指针指向原来第i个位置的节点 插入前： 插入后： //在带头结点的链表的第i个位置插入元素e bool ListInsert(LinkList &L,int i, ElemType e) { if(i<1) return false; LNode *p; //定义一个指针p int j
链表的建立和操作的讲解及其code
磊哥哥讲算法
01-09 577
#include<iostream> //typrdef<数据类型><别名> // lnode单链表 和sequence 顺序表 //为通俗易懂，假设int=elemtype，方便解读 using namespace std; typedef int Elemtype; struct Lnode { int data;// elemtype data;定义单链表结点类型 struct Lnode* next;// struct 存放数据元素和下一个结点，而且还要留意创
循环单链表的简单实现（C语言）
文溪山人的博客
03-21 3831
循环单链表的简单实现（C语言）
删除双向链表中第一个值为key的结点
Lemon_sj的博客
11-24 499
分析： 双向链表的图如下所示： 首先我们定义一个变量 cur 去遍历数组，当 cur.data = key的时候，我们就要分情况讨论了 我们先判断cur是不是头节点，如果是则执行相应的操作删掉Key 如果不是头节点，那么cur就只能是中间结点或者尾结点了。具体的代码实现如下： public void remove(int key){ ListNode cur = this.head;...
单链表的插入删除
weixin_50311592的博客
04-21 1544
单链表的插入和删除 ListInsert(&L,i,e):插入操作，在表L中的第i个位置上插入指定元素e，（找到第i-1个结点，将新节点插入其后） 按位序插入（带头结点） 存在第0个结点 //在第i个位置插入元素e（带头结点） bool LIstInsert(LinkList &L,int i,ElemTYpe e){ if(i<1) return false; LNode *p;//指针p指向当前扫描到的结点 int j=0;//当前p指向的是第几个
双向链表的节点删除
Regan
09-07 1246
void  ddeletenode(dlistnode*p)      {        p–>prior–>next=p–>next;        p–>next–>prior=p–>prior;        free(p);       }   注意：与单链表的插入和删除操作不同的是，在双链表中插入和删除必须同时修改两个方向上的指针。上述两个算是法的时间复杂度均为O(1)。
C语言实现链表操作
链表是一种在计算机科学中广泛使用的数据结构，尤其在C语言中，它的实现是编程基础的重要组成部分。链表不同于数组，它不连续存储数据，而是通过节点间的指针链接来表示逻辑顺序。每个节点包含两部分：数据域，用于...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值