【C 数据结构】双向链表

news2024/11/15 22:44:55

文章目录

  • 【 1. 基本原理 】
  • 【 2. 双向链表的 创建 】
    • 实例 - 输出双向链表
  • 【 3. 双向链表 添加节点 】
  • 【 4. 双向链表 删除节点 】
  • 【 5. 双向链表查找节点 】
  • 【 7. 双向链表更改节点 】
  • 【 8. 实例 - 双向链表的 增删查改 】

【 1. 基本原理 】

  • 表中各节点中都只包含一个指针（游标），且都统一指向直接后继节点，通常称这类链表为 单向链表（或单链表）。
  • 背景
    如果算法中需要大量地找某指定结点的前趋结点，使用单链表无疑是灾难性的，因为单链表更适合 “从前往后” 找，而 “从后往前” 找并不是它的强项。为了能够高效率解决类似的问题，引入双向链表（简称双链表）。
  • 从名字上理解 双向链表，即链表是 “双向” 的，（双向指的是各节点之间的逻辑关系是双向的） 每个节点存在前后两个指针，分别指向前驱节点和后继节点，但通常头指针只设置一个，除非实际情况需要。
    在这里插入图片描述
  • 双向链表中各节点包含以下 3 部分信息：
    • 前指针域：用于指向当前节点的直接前驱节点；
    • 数据域：用于存储数据元素。
    • 后指针域：用于指向当前节点的直接后继节点；
      在这里插入图片描述
  • 双链表的节点结构用 C 语言实现为：
typedef struct line
{
    struct line * prior; //指向直接前趋
    int data;
    struct line * next; //指向直接后继
}line;

【 2. 双向链表的 创建 】

  • 同单链表相比，双链表仅是各节点多了一个用于指向直接前驱的指针域。因此，我们可以在单链表的基础轻松实现对双链表的创建。
  • 需要注意的是，与单链表不同，双链表创建过程中，每创建一个新节点，都要与其前驱节点建立两次联系，分别是：
    • 将新节点的 prior 指针指向直接前驱节点；
    • 将直接前驱节点的 next 指针指向新节点；
  • 创建双向链表的 C 语言实现代码：
//双链表的创建函数
line* initLine(line* head,int x[],int N)
{
    //创建一个首元节点，链表的头指针为head
    head = (line*)malloc(sizeof(line));
    //对首元节点进行初始化
    head->prior = NULL;
    head->next = NULL;
    head->data = x[0];
    //声明一个指向尾巴节点的指针，方便后期向链表中添加新创建的节点
    line* list = head;
    for (int i = 1; i <N; i++)
    {
        //创建新的节点并初始化
        line* body = (line*)malloc(sizeof(line));
        body->prior = NULL;
        body->next = NULL;
        body->data = x[i];
        //新节点与链表最后一个节点建立关系
        list->next = body;
        body->prior = list;
        //list永远指向链表中最后一个节点
        list = list->next;
    }
    //返回新创建的链表
    return head;
}

实例 - 输出双向链表

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>

//双向链表结构体
typedef struct line
{
    struct line* prior;
    int data;
    struct line* next;
}line;

//双链表的创建函数
line* initLine(line* head,int x[],int N)
{
    //创建一个首元节点，链表的头指针为head
    head = (line*)malloc(sizeof(line));
    //对首元节点进行初始化
    head->prior = NULL;
    head->next = NULL;
    head->data = x[0];
    //声明一个指向尾巴节点的指针，方便后期向链表中添加新创建的节点
    line* list = head;
    for (int i = 1; i <N; i++)
    {
        //创建新的节点并初始化
        line* body = (line*)malloc(sizeof(line));
        body->prior = NULL;
        body->next = NULL;
        body->data = x[i];
        //新节点与链表最后一个节点建立关系
        list->next = body;
        body->prior = list;
        //list永远指向链表中最后一个节点
        list = list->next;
    }
    //返回新创建的链表
    return head;
}

//输出双链表的函数
void display(line* head)
{
    line* temp = head;
    while (temp)
    {
        //如果该节点无后继节点，说明此节点是链表的最后一个节点
        if (temp->next == NULL)
            printf("%d\n", temp->data);
        else
            printf("%d <-> ", temp->data);
        temp = temp->next;
    }
}

int main()
{
    int N;
    printf("请输入链表的数量：");
    scanf("%d",&N);
    printf("请输入链表的元素：");
    int* x = new int[N];
    for (int i = 0; i < N; ++i)
        scanf("%d", &x[i]);
    //创建一个头指针
    line* head = NULL;
    //调用链表创建函数
    head = initLine(head,x,N);
    //输出创建好的链表
    display(head);
    //显示双链表的优点
    printf("链表中第 4 个节点的直接前驱是：%d", head->next->next->next->prior->data);
    return 0;
}

在这里插入图片描述

【 3. 双向链表 添加节点 】

  • 添加至表头
    将新数据元素添加到表头，只需要将该元素与表头元素建立双层逻辑关系即可。换句话说，假设新元素节点为 temp，表头节点为 head，则需要做以下 2 步操作即可：
    • 新节点与头节点连接：temp->next=head; head->prior=temp;
    • head指向新节点：将 head 移至 temp，重新指向新的表头；

例如，将新元素 7 添加至双链表的表头，则实现过程如图 2 所示：
在这里插入图片描述

  • 添加至表的中间位置
    同单链表添加数据类似，双向链表中间位置添加数据需要经过以下 2 个步骤，如下图所示：
    • 新节点先与其直接后继节点建立双层逻辑关系；
    • 新节点的直接前驱节点与之建立双层逻辑关系；
      在这里插入图片描述
  • 添加至表尾
    与添加到表头是一个道理，更简单，实现过程如下：
    • 找到双链表中最后一个节点；
  • 让新节点与最后一个节点进行双层逻辑关系；
    在这里插入图片描述
  • C 语言实现
line * insertLine(line * head,int data,int add)
{
    //新建数据域为data的结点
    line * temp=(line*)malloc(sizeof(line));
    temp->data=data;
    temp->prior=NULL;
    temp->next=NULL;
    //插入到链表头，要特殊考虑
    if (add==1) 
    {
        temp->next=head;
        head->prior=temp;
        head=temp;
    }
    else
    {
        line * body=head;
        //找到要插入位置的前一个结点body
        for (int i=1; i<add-1; i++) 
        {
            body=body->next;
        }
        //判断条件为真，说明插入位置为链表尾
        if (body->next==NULL) 
        {
            body->next=temp;
            temp->prior=body;
        }
        else
        {
            body->next->prior=temp;//新节点后1个节点的前向指针指向新节点
            temp->next=body->next;//新节点的后向指针指向后一个节点
            body->next=temp;//新节点前1个节点的后向指针指向新节点
            temp->prior=body;//新节点的前向指针指向前一个节点
        }
    }
    return head;
}

【 4. 双向链表 删除节点 】

-双链表删除结点时，只需遍历链表找到要删除的结点，然后将该节点从表中摘除即可。

  • 删除元素 2 的操作过程，如下图所示：
    在这里插入图片描述
  • 双向链表删除节点的 C 语言实现代码如下：
line* delLine(line* head, int data)
{
    line* temp = head;
    //遍历链表
    while (temp)
    {
        if (temp->prior == NULL && temp->data == data)//删除头节点
        {
            temp->next->prior = NULL;
            return head->next;
        }
        else if (temp->next == NULL && temp->data == data) //删除尾节点
        {
            temp->prior->next = NULL;
            return head;
        }
        else if (temp->data == data)
        {
            temp->prior->next = temp->next;
            temp->next->prior = temp->prior;
            free(temp);
            return head;
        }
        temp = temp->next;
    }
    printf("链表中无该数据元素");
    return head;
}

【 5. 双向链表查找节点 】

  • 通常，双向链表同单链表一样，都仅有一个头指针。因此，双链表查找指定元素 的实现同单链表类似，都是 从表头依次遍历表中元素。
  • C 语言实现代码为：
//head为原双链表，elem表示被查找元素
int selectElem(line * head,int elem)
{
//新建一个指针t，初始化为头指针 head
    line * t=head;
    int i=1;
    while (t) 
    {
        if (t->data==elem) 
        {
            return i;
        }
        i++;
        t=t->next;
    }
    //程序执行至此处，表示查找失败
    return -1;
}

【 7. 双向链表更改节点 】

  • 更改双链表中指定结点数据域的操作是在查找的基础上完成的。实现过程是：通过遍历找到存储有该数据元素的结点，直接更改其数据域即可。
  • 实现此操作的 C 语言实现代码如下：
//更新函数，其中，add 表示更改结点在双链表中的位置，newElem 为新数据的值
line *amendElem(line * p,int add,int newElem)
{
    line * temp=p;
    //遍历到被删除结点
    for (int i=1; i<add; i++) 
    {
        temp=temp->next;
    }
    temp->data=newElem;
    return p;
}

【 8. 实例 - 双向链表的 增删查改 】

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
//双向链表结构体
typedef struct line
{
    struct line* prior;
    int data;
    struct line* next;
}line;
//双链表的创建
line* initLine(line* head,int x[],int N);
//双链表插入元素，add表示插入位置
line* insertLine(line* head, int data, int add);
//双链表删除指定元素
line* delLine(line* head, int data);
//双链表中查找指定元素
int selectElem(line* head, int elem);
//双链表中更改指定位置节点中存储的数据，add表示更改位置
line* amendElem(line* p, int add, int newElem);
//输出双链表的实现函数
void display(line* head);

int main()
{
    int x[5] = {1,3,5,7,9};
    //创建一个头指针
    line* head = NULL;
    //调用链表创建函数
    head = initLine(head, x, 5);
    display(head);
    
    printf("在表中第 3 的位置插入数据 66 后:\n");
    head = insertLine(head, 66, 3);
    display(head);
    
    //表中删除元素9
    printf("表中删除元素 9后:\n");
    head = delLine(head, 9);
    display(head);
    printf("元素 3 的位置是：%d\n", selectElem(head, 3));
   
    //表中第 3 个节点中的数据改为存储 8
    printf("表中第 3 个节点中的数据改为数据 8后:\n");
    head = amendElem(head, 3, 8);
    display(head);
    return 0;
}

//双链表的创建函数
line* initLine(line* head, int x[], int N)
{
    //创建一个首元节点，链表的头指针为head
    head = (line*)malloc(sizeof(line));
    //对首元节点进行初始化
    head->prior = NULL;
    head->next = NULL;
    head->data = x[0];
    //声明一个指向尾巴节点的指针，方便后期向链表中添加新创建的节点
    line* list = head;
    for (int i = 1; i < N; i++)
    {
        //创建新的节点并初始化
        line* body = (line*)malloc(sizeof(line));
        body->prior = NULL;
        body->next = NULL;
        body->data = x[i];
        //新节点与链表最后一个节点建立关系
        list->next = body;
        body->prior = list;
        //list永远指向链表中最后一个节点
        list = list->next;
    }
    //返回新创建的链表
    return head;
}


line* insertLine(line* head, int data, int add)
{
    //新建数据域为data的结点
    line* temp = (line*)malloc(sizeof(line));
    temp->data = data;
    temp->prior = NULL;
    temp->next = NULL;
    //插入到链表头，要特殊考虑
    if (add == 1)
    {
        temp->next = head;
        head->prior = temp;
        head = temp;
    }
    else
    {
        line* body = head;
        //找到要插入位置的前一个结点
        for (int i = 1; i < add - 1; i++)
        {
            body = body->next;
        }
        //判断条件为真，说明插入位置为链表尾
        if (body->next == NULL)
        {
            body->next = temp;
            temp->prior = body;
        }
        else
        {
            body->next->prior = temp;
            temp->next = body->next;
            body->next = temp;
            temp->prior = body;
        }
    }
    return head;
}
line* delLine(line* head, int data)
{
    line* temp = head;
    //遍历链表
    while (temp)
    {
        if (temp->prior == NULL && temp->data == data)//删除头节点
        {
            temp->next->prior = NULL;
            return head->next;
        }
        else if (temp->next == NULL && temp->data == data) //删除尾节点
        {
            temp->prior->next = NULL;
            return head;
        }
        else if (temp->data == data)
        {
            temp->prior->next = temp->next;
            temp->next->prior = temp->prior;
            free(temp);
            return head;
        }
        temp = temp->next;
    }
    printf("链表中无该数据元素");
    return head;
}
//head为原双链表，elem表示被查找元素
int selectElem(line* head, int elem)
{
    //新建一个指针t，初始化为头指针 head
    line* t = head;
    int i = 1;
    while (t)
    {
        if (t->data == elem)
        {
            return i;
        }
        i++;
        t = t->next;
    }
    //程序执行至此处，表示查找失败
    return -1;
}
//更新函数，其中，add 表示更改结点在双链表中的位置，newElem 为新数据的值
line* amendElem(line* p, int add, int newElem)
{
    line* temp = p;
    //遍历到被删除结点
    for (int i = 1; i < add; i++)
    {
        temp = temp->next;
    }
    temp->data = newElem;
    return p;
}
//输出链表的功能函数
void display(line* head)
{
    line* temp = head;
    while (temp)
    {
        if (temp->next == NULL)
        {
            printf("%d\n", temp->data);
        }
        else
        {
            printf("%d->", temp->data);
        }
        temp = temp->next;
    }
}

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1595560.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

排序算法-基数排序

排序算法-基数排序

基数排序是一种非比较排序算法&#xff0c;它将待排序的数字按照位数进行排序。基数排序的思想是先按照个位数进行排序&#xff0c;然后按照十位数进行排序&#xff0c;接着按照百位数进行排序&#xff0c;以此类推&#xff0c;直到最高位排序完成。 基数排序的步骤如下&#x…
阅读更多...
【Java】xxl-job的快速入门

【Java】xxl-job的快速入门

目录 什么是xxl-job&#xff1f; XXL-Job-环境搭建 1 调度中心环境要求 2.XXL-Job(源码说明) 3.初始化“调度数据库” 3启动调度中心xxl-job-admin docker安装-配置调度中心 1.创建mysql容器&#xff0c;初始化xxl-job的SQL脚本 2.拉取镜像 3.创建容器 xxl-jo…
阅读更多...
手机号三要素实名验证，为您打造安全可靠的账户环境

手机号三要素实名验证，为您打造安全可靠的账户环境

在互联网时代&#xff0c;手机号码成为了我们生活中必不可少的一部分。我们几乎所有的社交账号、银行账号、网购账号&#xff0c;都需要绑定手机号码进行认证。然而&#xff0c;随着互联网的发展&#xff0c;越来越多的账号被盗用、个人信息被泄露的案例频频发生&#xff0c;让…
阅读更多...
ros2 launch gazebo_ros gazebo.launch.py无法启动

ros2 launch gazebo_ros gazebo.launch.py无法启动

我的系统是ubuntu20.04&#xff0c;ros2的版本是humble&#xff0c;当运行gazebo仿真时&#xff0c;运行 ros2 launch gazebo_ros gazebo.launch.py命令&#xff0c;会出现以下问题&#xff1a; 此时&#xff0c;这个页面会卡死在第六行&#xff0c;gazebo也不会打开 但最后单…
阅读更多...
软件无线电安全之HackRF One初探

软件无线电安全之HackRF One初探

HackRF介绍 HackRF是一款开源软件无线电&#xff08;SDR&#xff09;平台&#xff0c;由Great Scott Gadgets公司推出。它具有广泛的频率覆盖范围&#xff0c;从1 MHz到6 GHz&#xff0c;支持大部分常见的无线通信频段。采用软件定义无线电技术&#xff0c;HackRF提供了自定义…
阅读更多...
香港服务器如何更换域名？

香港服务器如何更换域名？

更换香港服务器的域名是一个相对复杂的过程&#xff0c;涉及到多个步骤和注意事项。 准备工作&#xff1a; 备份网站数据&#xff1a;在进行任何更改之前&#xff0c;务必备份您的网站数据&#xff0c;以防止数据丢失或损坏。 购买新的域名&#xff1a;如果您还没有购买新的…
阅读更多...
职场如何有效学习充电

职场如何有效学习充电

在现在的工作中&#xff0c;需要接触和了解各式各样的内容&#xff0c;但很多时候我自己没遇到过。而平时有感觉没什么时间&#xff0c;因此产生了这个疑问&#xff0c;看完这个课程后&#xff0c;对这块有了较为体系化的了解。 对我来说&#xff0c;学习的最终目的是充实自己…
阅读更多...
【AI 斯坦福 STORM】基于互联网搜索，帮你从零开始撰写文章

【AI 斯坦福 STORM】基于互联网搜索，帮你从零开始撰写文章

今天介绍斯坦福出品的系统&#xff0c;STORM。 STORM是一个基于互联网搜索的LLM系统&#xff0c;可以从零开始撰写类似维基百科的文章。 技术栈&#xff1a; dspy 一个用于算法优化LM提示和权重的框架You.com搜索API YOU APIs利用实时网络数据使LLMs和搜索体验更加真实和及时…
阅读更多...
力扣 | 148. 排序链表

力扣 | 148. 排序链表

和数组里面的归并排序思想一致 class Solution {public ListNode sortList(ListNode head) {//过滤条件if(head null || head.next null)return head;ListNode slow head;ListNode fast head.next;while (fast ! null && fast.next ! null){slow slow.next;fast …
阅读更多...
【Maven工具】

【Maven工具】

maven Maven是一个主要用于Java项目的构建自动化工具。它有助于管理构建过程&#xff0c;包括编译源代码、运行测试、将编译后的代码打包成JAR文件以及管理依赖项。Maven使用项目对象模型&#xff08;POM&#xff09;文件来描述项目配置和依赖关系。 Maven通过提供标准的项目…
阅读更多...
酷开系统让用户在方方面面享受科技进步带来的美好体验

酷开系统让用户在方方面面享受科技进步带来的美好体验

电视本身的特性&#xff0c;再有人工智能和全时AI的加持&#xff0c;让搭载了酷开系统的电视有能力成为一个“家庭智慧管控中心”。互联网的存在让大家能更懒地完成事情&#xff0c;满足宅家的愿望&#xff0c;有话说&#xff0c;科技因懒人而进步。打个简单的比方&#xff0c;…
阅读更多...
手机照片删除了怎么恢复？恢复iPhone照片，试试这4招

手机照片删除了怎么恢复？恢复iPhone照片，试试这4招

当手机上的珍贵照片意外被删除时&#xff0c;让人心急如焚。幸运的是&#xff0c;对于使用iPhone的用户来说&#xff0c;恢复被删除的照片并不是一件难事。即使你不小心删除了照片&#xff0c;仍然有一些方法可以尝试将它们找回。手机照片删除了怎么恢复&#xff1f;在本文中&a…
阅读更多...
计算机网络—传输层UDP协议：原理、应用

计算机网络—传输层UDP协议：原理、应用

​ &#x1f3ac;慕斯主页&#xff1a;修仙—别有洞天 ♈️今日夜电波&#xff1a;2月のセプテンバー 1:21━━━━━━️&#x1f49f;──────── 5:21 &#x1f504; ◀️ ⏸ ▶️ ☰ &am…
阅读更多...
交叉熵损失函数介绍

交叉熵损失函数介绍

交叉熵是信息论中的一个重要概念&#xff0c;它的大小表示两个概率分布之间的差异&#xff0c;可以通过最小化交叉熵来得到目标概率分布的近似分布。 为了理解交叉熵&#xff0c;首先要了解下面这几个概念。 自信息 信息论的基本想法是&#xff0c;一个不太可能的事件发生了…
阅读更多...
【leetcode面试经典150题】51. 用最少数量的箭引爆气球（C++）

【leetcode面试经典150题】51. 用最少数量的箭引爆气球（C++）

【leetcode面试经典150题】专栏系列将为准备暑期实习生以及秋招的同学们提高在面试时的经典面试算法题的思路和想法。本专栏将以一题多解和精简算法思路为主&#xff0c;题解使用C语言。&#xff08;若有使用其他语言的同学也可了解题解思路&#xff0c;本质上语法内容一致&…
阅读更多...
【学习笔记十六】EWM常见下架策略介绍

【学习笔记十六】EWM常见下架策略介绍

一、FIFO（First in ，First out）先进先出下架策略 1.后台配置 ①定义出库规则 字段： WDATU：收货日期和时间 或者WDATU_DATE收货日期无时间 QUAN：可用数量 排序： 不勾选升序，勾选降序 ②指定仓库类型搜索顺序 ③确定出库的存储类型搜索顺序 ②和③的配置详情见…
阅读更多...
Android MVVM架构学习——ViewModel DataBinding

Android MVVM架构学习——ViewModel DataBinding

关于MVVM架构&#xff0c;我并不想花篇幅去做重复性的描述&#xff0c;网上一搜都是一堆讲解&#xff0c;大家可以自行了解&#xff0c;我所做的只是以最简单的例子&#xff0c;最有效的步骤&#xff0c;从零开始&#xff0c;去实现一个相对有点学习参考价值的项目。 先来看本…
阅读更多...
无人机GB42590接收端 +接收端，同时支持2.4G与5.8G双频WIFI模组

无人机GB42590接收端 +接收端，同时支持2.4G与5.8G双频WIFI模组

严格按照GB42590的协议开发的发射端&#xff0c;通过串口和模块通讯&#xff0c;默认波特率 921600。 http://www.doit.am/首页-深圳四博智联科技有限公司-淘宝网https://shop144145132.taobao.com/?spma230r.7195193.1997079397.2.71f6771dJHT2r0 二、接口文档 单片机和模…
阅读更多...
【web3技术】什么是 WEB3？

【web3技术】什么是 WEB3？

Web3 简介 中心化网络已经帮助数十亿人融入了互联网，并在其上创建了稳定、可靠的基础设施。 与此同时，少数中心化巨头几乎垄断了互联网，甚至可以为所欲为。 Web3 是摆脱这一困境的方案。 不同于科技巨头垄断的传统互联网，Web3 采用去中心化，由所有用户构建、运营和拥有。…
阅读更多...
探索数据结构：顺序串与链式串的深入理解

探索数据结构：顺序串与链式串的深入理解

✨✨ 欢迎大家来到贝蒂大讲堂✨✨ &#x1f388;&#x1f388;养成好习惯&#xff0c;先赞后看哦~&#x1f388;&#x1f388; 所属专栏&#xff1a;数据结构与算法 贝蒂的主页&#xff1a;Betty’s blog 1. 串的定义 串是一种特殊的顺序表&#xff0c;即每一个元素都是单独一…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023