双链表的定义及基本操作

已于 2024-08-11 09:59:37 修改
阅读量241 收藏 2
点赞数 8
文章标签： 链表 数据结构
于 2024-08-10 22:12:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74796479/article/details/141097012
版权

 学习完双链表做一下记录以防忘记，有错误希望大家可以多多指正。

这段代码首先定义了一个双链表的结构体 Lnode ，其中包含数据 a 以及指向前驱和后继节点的指针 prev 和 next 。

接下来，实现了一系列双链表的操作函数：

  • ListInit 用于初始化双链表的头节点。
  • ListIsEmpty 用于判断双链表是否为空。
  • ListPrint 用于打印双链表中的元素。
  • ListLength 用于计算双链表的长度。
  • ListCreatH 以头插法创建双链表。
  • ListCreatR 以尾插法创建双链表。
  • ListInsert 实现向指定位置插入元素。
  • ListSearchByValue 按值查找链表中的节点。
  • ListSearchByPosition 按位置查找链表中的节点。
  • ListDel 删除指定位置的节点。
  • ClearList 用于释放整个双链表的内存。

1. 创建结构体：

//创建结构体
typedef struct Lnode{
	int a;
	Lnode* prev, * next;
}Lnode;

2. 初始化链表

// 初始化链表
void ListInit(Lnode** L) {
    // 为头节点分配内存
    (*L) = (Lnode*)malloc(sizeof(Lnode));
    // 初始化头节点的指针
    (*L)->next = NULL;
    (*L)->prev = NULL;
}

3. 打印链表

// 打印链表
void ListPrint(Lnode** L) {
    Lnode* p = (*L);
    // 遍历链表并打印节点的值
    while (p->next!= NULL) {
        cout << p->next->a << " ";
        p = p->next;
    }
    cout << endl;
}

4. 判断链表是否为空

// 判断链表是否为空
bool ListIsEmpty(Lnode** L) {
	return (*L)->next == NULL;
}

5. 求双链表的长度

// 求双链表的长度
int ListLength(Lnode** L) {
	int length = 0;
	Lnode* p = (*L)->next;
	while (p != NULL) {
		length++;
		p = p->next;
	}
	return length;
}

6. 头插法建立双链表

// 头插法建立双链表
bool ListCreatH(Lnode** L){
    int x;
    cout << "请输入数据（输入 0 结束）：" << endl;
    cin >> x;
    // 循环输入并插入节点
    while (x!= 0) {
        Lnode* N = (Lnode*)malloc(sizeof(Lnode));
        N->a = x;
        N->next=(*L)->next;
        // 如果头节点的下一个节点不为空，更新其前驱指针
        if ((*L)->next!=NULL) {
            (*L)->next->prev = N;
        }
        N->prev = (*L);
        (*L)->next = N;
        cin >> x;
    }
    return true;
}

7. 尾插法建立双链表

// 尾插法建立双链表
bool ListCreatR(Lnode** L) {
    int x;
    cout << "请输入数据（输入 0 结束）：" << endl;
    cin >> x;
    Lnode* R = (*L);
    // 循环输入并在尾部插入节点
    while (x!= 0) {
        Lnode* N = (Lnode*)malloc(sizeof(Lnode));
        N->a = x;
        R->next = N;
        N->prev = R;
        N->next = NULL;
        R = N;
        cin >> x;
    }
    
    R = NULL;
    return true;
}

8. 按值查找

// 按值查找
Lnode* ListSearchByValue(Lnode** L, int value) {
	Lnode* p = (*L)->next;
	while (p != NULL) {
		if (p->a == value) {
			return p;
		}
		p = p->next;
	}
	return NULL;
}

9. 按位查找

Lnode* ListSearchByPosition(Lnode** L, int position) {
	if (position <= 0) {
		return NULL;
	}
	Lnode* p = (*L)->next;
	int count = 1;
	while (p != NULL && count < position) {
		p = p->next;
		count++;
	}
	if (count == position) {
		return p;
	}	
	return NULL;
}

10. 数据插入

// 数据插入
bool ListInsert(Lnode** L, int i, int e) {
    // 如果插入位置不合法，返回 false
    if (i <= 0) return false;
    Lnode* P = (*L);
    // 找到要插入的位置
    while (--i){
        if (P == NULL) return false;
        P = P->next;
    }
    Lnode* N = (Lnode*)malloc(sizeof(Lnode));
    N->a = e;
    // 调整指针完成插入
    N->next = P->next;
    N->prev = P;
    if (P->next!= NULL) {
        P->next->prev = N;
    }
    P->next = N;
    return true;
}

11. 删除节点

// 删除节点
bool ListDel(Lnode** L, int i, int& e) {
    // 如果删除位置不合法，返回 false
    if (i <= 0) return false;
    Lnode* P = (*L);
    // 找到要删除节点的前一个节点
    while (--i) {
        if (P == NULL) return false;
        P = P->next;
    }
    Lnode* temp = P->next;
    // 调整指针完成删除
    if (P->next->next!= NULL) {
        P->next->next->prev = P;
    }
    P->next = P->next->next;
    free(temp);
    return true;
}

12. 删除整条链表

// 删除整条链表
void ClearList(Lnode** L) {
    Lnode* P = (*L);
    // 逐个释放链表节点内存
    while (P!= NULL) {
        (*L) = (*L)->next;
        free(P);
        P = (*L);
    }
    (*L) = NULL;
}

在 main 函数中，我们首先初始化一个双链表，并使用尾插法创建链表。然后进行了删除节点、打印链表、获取链表长度、判断链表是否为空、按位置查找节点等操作。

测试代码：

#include <iostream>

using namespace std;

//创建结构体
typedef struct Lnode{
	int a;
	Lnode* prev, * next;
}Lnode;

// 初始化链表
void ListInit(Lnode** L) {
	// 为头节点分配内存
	(*L) = (Lnode*)malloc(sizeof(Lnode));
	// 初始化头节点的指针
	(*L)->next = NULL;
	(*L)->prev = NULL;
}

// 判断链表是否为空
bool ListIsEmpty(Lnode** L) {
	return (*L)->next == NULL;
}

// 打印链表
void ListPrint(Lnode** L) {
	Lnode* p = (*L);
	// 遍历链表并打印节点的值
	while (p->next != NULL) {
		cout << p->next->a << " ";
		p = p->next;
	}
	cout << endl;
}

// 求双链表的长度
int ListLength(Lnode** L) {
	int length = 0;
	Lnode* p = (*L)->next;
	while (p != NULL) {
		length++;
		p = p->next;
	}
	return length;
}

// 头插法建立双链表
bool ListCreatH(Lnode** L) {
	int x;
	cout << "请输入数据（输入 0 结束）：" << endl;
	cin >> x;
	// 循环输入并插入节点
	while (x != 0) {
		Lnode* N = (Lnode*)malloc(sizeof(Lnode));
		N->a = x;
		N->next = (*L)->next;
		// 如果头节点的下一个节点不为空，更新其前驱指针
		if ((*L)->next != NULL) {
			(*L)->next->prev = N;
		}
		N->prev = (*L);
		(*L)->next = N;
		cin >> x;
	}
	return true;
}

// 尾插法建立双链表
bool ListCreatR(Lnode** L) {
	int x;
	cout << "请输入数据（输入 0 结束）：" << endl;
	cin >> x;
	Lnode* R = (*L);
	// 循环输入并在尾部插入节点
	while (x != 0) {
		Lnode* N = (Lnode*)malloc(sizeof(Lnode));
		N->a = x;
		R->next = N;
		N->prev = R;
		N->next = NULL;
		R = N;
		cin >> x;
	}
	// 这一步将 R 置为 NULL 并非必要
	R = NULL;
	return true;
}


// 数据插入
bool ListInsert(Lnode** L, int i, int e) {
	// 如果插入位置不合法，返回 false
	if (i <= 0) return false;
	Lnode* P = (*L);
	// 找到要插入的位置
	while (--i) {
		if (P == NULL) return false;
		P = P->next;
	}
	Lnode* N = (Lnode*)malloc(sizeof(Lnode));
	N->a = e;
	// 调整指针完成插入
	N->next = P->next;
	N->prev = P;
	if (P->next != NULL) {
		P->next->prev = N;
	}
	P->next = N;
	return true;
}

// 按值查找
Lnode* ListSearchByValue(Lnode** L, int value) {
	Lnode* p = (*L)->next;
	while (p != NULL) {
		if (p->a == value) {
			return p;
		}
		p = p->next;
	}
	return NULL;
}

// 按位查找
Lnode* ListSearchByPosition(Lnode** L, int position) {
	if (position <= 0) {
		return NULL;
	}
	Lnode* p = (*L)->next;
	int count = 1;
	while (p != NULL && count < position) {
		p = p->next;
		count++;
	}
	if (count == position) {
		return p;
	}	
	return NULL;
}
// 删除节点
bool ListDel(Lnode** L, int i, int& e) {
	// 如果删除位置不合法，返回 false
	if (i <= 0) return false;
	Lnode* P = (*L);
	// 找到要删除节点的前一个节点
	while (--i) {
		if (P == NULL) return false;
		P = P->next;
	}
	Lnode* temp = P->next;
	e = temp->a;
	// 调整指针完成删除
	if (P->next->next != NULL) {
		P->next->next->prev = P;
	}
	P->next = P->next->next;
	free(temp);
	return true;
}

// 删除整条链表
void ClearList(Lnode** L) {
	Lnode* P = (*L);
	// 逐个释放链表节点内存
	while (P != NULL) {
		(*L) = (*L)->next;
		free(P);
		P = (*L);
	}
	(*L) = NULL;
}
int main() {
	Lnode* L;
	ListInit(&L);
	//尾插法创建链表
	ListCreatR(&L);
	cout << "您创建的链表是：";
	ListPrint(&L);
	int e;
	ListDel(&L, 1, e);
	cout << "删除第一个节点后为:";
	ListPrint(&L);
	cout << "删除的节点是：" << e << endl;
	cout << "链表长度为：" << ListLength(&L) << endl;
	cout <<"是否为空："<< (bool)ListIsEmpty(&L) << endl;
	Lnode* P = ListSearchByPosition(&L, 3);
	if (P != NULL) cout << "第三个元素为：" << P->a;
	else cout << "未查询到节点三" << endl;
	
	ClearList(&L);
	
	return 0;
	
}

输出示例：

青亮-
关注
双向链表的定义及基本操作
IT80hcbz的博客
03-31 441
《匠人的算法课II》为数据结构和算法系列课程的进阶课程。本讲为第一讲，大家详细介绍双向链表的定义以及基本操作。
双链表的基本操作
WeiMengXuan的博客
04-03 569
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。双链表的基本操作有以下：DListNode* BuyDListNode(DataType x); //申请内存空间 DListNode* DListInit(); //初始化 void DListD...
【数据结构】双链表定义及基本操作
CoderMateng的博客
01-07 608
//双链表定义及各类操作 #include<stdio.h> #include<string.h> #include<stdlib.h> #include<stdbool.h> typedef int Elemtype; //定义双链表节点类型 typedef struct DLinkList { Elemtype data; //数据域 struct DLinkList *prior, *next; //前驱指针，后继指针 } DLink
双向链表定义及基本操作的java实现
weixin_40389106的博客
01-19 696
双向链表 与单向链表的对比： （1）、单向链表的查找只有一个方向，而双向链表可以向前和向后查找； （2）、双向链表可以实现自我删除；而单链表删除一个节点必须要借助辅助节点，即需要删除节点的前一个节点。 双链表基本操作的实现思路： （1）、遍历：方式和单链表一样，仅仅是多了双向查找的功能； （2）、添加（到双链表最后）： 1、首先找到双链表的最后一个节点； 2、temp.next = n...
数据结构 双向链表及其基本操作
Mi-ronin的博客
03-17 7514
双向链表的一系列操作讲解及代码
C语言数据结构 双向链表的建立与基本操作
01-01
C语言数据结构 双向链表的建立与基本操作 双向链表比单链表有更好的灵活性，其大部分操作与...由于定义双向链表时指针域中多了一个prior指针，插入操作相应变得复杂，但基本操作也并不难理解。只需记住在处理前驱和后
数据结构(C语言)中双向链表的定义及基本操作
Winda_shi的博客
11-21 1198
单链表中的结点只有一个指向其后继的指针，使得单链表要访问某个结点的前驱结点时，只能从头开始遍历，而双向链表的话 可以直接访问结点的后继结点和前驱结点。双链表的结点中有两个指针prior和next，分别指向前驱结点和后继结点。双链表与单链表在某些操作上大同小异。一、双向链表的定义及基本操作。
2.4 双链表表结构体定义和基本操作1
08-03
【双链表的基本操作】 1. **尾插法建立双链表**：创建一个新的节点并将其添加到双链表的末尾。在C#中，可以使用以下方法实现： ```csharp public void Append(DoublyLinkedListNode head, int value) { if (head ...
C 双向链表的所有基本操作.zip
12-20
在C语言中实现双向链表的基本操作通常包括以下几个部分： 1. **节点结构定义**：首先，我们需要定义一个结构体来表示链表节点。这个结构体通常包含数据域（用于存储数据）和两个指针域，分别指向下一个节点和前一个...
数据结构应用实例(四)——最小生成树
Blogs of zcy1221
09-10 1218
每次选择最近顶点，需要进行一次遍历，比较 N 次，之后将其添加进最小生成树，更新 weight 和 pre，一次遍历，N 次操作，总共需要选择 N-1 次，所以 prim 算法的时间复杂度为。4、 kruskal 算法，为图的结构体添加成员 E ——存放边的结构体数组，成员为两节点编号和边的权值，这样在创建图时，可以直接创建 E，同时，图的数据文件中添加边的条数；综合所述，Prim 算法适合顶点相对较少而边相对稠密的网的最小生成树的求解，而 Kruskal 算法适合于求边比较稀疏的网的最小生成树；
【数据结构-二维前缀最小值】力扣3148. 矩阵中的最大得分
最新发布
sjsjs11的博客
09-11 1008
也就是说，当grid[i][j]为终点的时候，要在以(0,0)为左上角，(i,j)为右下角的矩阵中（不包括(i,j)）找到最小的那个元素值mn。如果用列来表示我们需要的信息，也就是从0到j-1列的最小值，然后第j列的从0到i-1行的最小值，这两个最小值我们进行比较，更小的那个就是我们需要的信息。所以说在遍历每一行的时候，我们都要重置pre_min为INT_MAX，pre_min的作用就是找到从0到j-1列的最小值，col_min的作用就是储存第j列的从0到i-1行的最小值。
数据结构----树
2301_77841194的博客
09-07 996
1、树(Tree)是n(n≥0)个结点的有限集。n=O时称为空树。在任意一棵非空树中:(1）有且仅有一个特定的称为根(Root)的结点;(2)当n>1时,其余结点可分为m(m>0)个互不相交的有限集T1、T2、……、Tm,其中每一个集合本身又是一棵树,并且称为根的子树(SubTree)2、树的结点包含一个数据元素及若干指向其子树的分支。结点拥有的子树数称为结点的度(Degree)。度为0的结点称为叶结点（Leaf）或终端结点;度不为0的结点称为非终端结点或分支结点。
数据结构归并两个链表并按照学号升序
wsdsbtzk的博客
09-07 384
int id;int score;int N,M;cin>>N>>M;return 0;i<n;i++)Student* q;while(p!=NULL)q=p;p=p->next;free(q);=NULL)p=p->next;p->next=s2;=NULL)
Java-数据结构-栈和队列-Stack和Queue (oﾟ▽ﾟ)o
2303_80388948的博客
09-07 920
栈：是一种特殊的线性表，其 只允需在固定的一端进行插入和删除操作。 进行插入和删除的一端叫做栈顶，另一端叫做栈底。并且要遵循 先进后出 的规则。 队列：是一种只允许一端进行插入元素，在另一端进行删除元素的特殊的线性表。 队列具有 先进先出 的性质：进行插入的一端叫做队尾，进行删除的一端叫做队头。也就是队尾进，队头出。
浙大数据结构：04-树6 Complete Binary Search Tree
qq_74924951的博客
09-10 580
int n;i < n;int f = 1;i < n;elseint n;return;i < n;int f = 1;i < n;else。
数据结构应用实例(一)——中缀表达式
Blogs of zcy1221
09-10 1156
它的基本思想是：对文法中的每一个非终结符编写一个函数（或子程序），函数名是相应的非终结符，函数体是根据规则右部符号串的结构编写，函数（或子程序）功能是识别由该非终结符所表示的语法成分。，弹栈，将弹出的操作符放入后缀表达式，直到遇到左括号或者栈为空时，停止弹栈，将扫描到的操作符入栈；扫描完中缀表达式之后，如果栈仍不空，弹栈，将弹出的操作符放入后缀表达式，直到栈为空；最后，如果后缀表达式合法的话，栈中应只剩一个数值，便是最终结果，将其返回；如果扫描到右括号，则弹栈，将弹出的操作符放到后缀表达式中，直到弹出左。
【数据结构和算法实践-树-LeetCode110-平衡二叉树】
Mao_c的博客
09-10 868
leetcode b树
常见的排序
2302_79712403的博客
09-07 892
常见的10大排序，这里先详细的介绍前7种排序；稳定性定义：如果两个元素具有相同的关键字，那么在排序后他们的相对顺序不变；排序前有标记的5在前面，排序后依旧在前面即稳定，如果位置互换了就不稳定；
【数据结构】堆——堆排序与海量TopK问题
Eraser的博客
09-08 1110
上一篇我们学习了堆的数据结构，现在我们来看看堆的日常应用和排序建堆的时间复杂度是O(N)，排序的时间复杂度是，整体是，具体怎么算出来的大家可以看下面内容。建堆需要从倒数第一个非叶子结点开始调整，从后往前，直到堆顶的数据最后一个非叶子结点的计算方式：n - 1是最后一个节点的下标，父亲 = (孩子 - 1) / 2，所以(n - 1 - 1) / 2end是最后一个数据的下标，我们先交换，在向下调整，就传过去了end(n-1)个要调整的数据，正好排除掉了最后已经排序好的数据。end > 0。
双向链表实现与频度操作
"这篇代码实现了一个简单的双向链表数据结构，并包含了对链表的基本操作，如初始化、清除、销毁、检查是否为空以及获取链表长度。同时，链表节点中包含了一个`freq`字段，用于记录元素的频度。" 在数据结构中，双向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值