双链表有头节点

最新推荐文章于 2024-07-12 18:02:43 发布
最新推荐文章于 2024-07-12 18:02:43 发布
阅读量383 收藏 7
点赞数 9
文章标签： 算法 数据结构 c语言 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_67152404/article/details/134640102
版权 
#ifndef __DOUBLE_H__
#define __DOUBLE_H__
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

typedef int Elemtype;
struct Node
{
    Elemtype data;     // 数据域
    struct Node *prev; // 指向上一个节点
    struct Node *next; // 指向下一个节点
};

struct Head
{
    struct Node *first;
    struct Node *last;
    int num;
};

extern struct Head *Create_Empty_DoubleLinkedListWithHead();
extern struct Head *Create_Empty_DoubleLinkedListWithHead_1();
extern struct Head *Create_Input_DoubleLinkedListWithHead();
extern bool Is_Head(struct Head *head);
extern void Print_DoubleLinkedListWithHead(struct Head *head);
extern struct Head *Insert_node_y(struct Head *head, Elemtype x, Elemtype y);
extern struct Head *Insert_node_y_2(struct Head *head, Elemtype x, Elemtype y);
extern void Delete_all_x(struct Head *head, Elemtype x);
extern void Delete_all_x_2(struct Head *head, Elemtype x);

#endif
#include "double.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

/*
        Create_Empty_DoubleLinkedListWithHead:创建一条带头结点的空双向链表

        返回值:
            返回头节点地址
*/
struct Head *Create_Empty_DoubleLinkedListWithHead()
{
    struct Head *p = malloc(sizeof(*p));
    if (p == NULL)
        return NULL;
    p->first = malloc(sizeof(*p));
    if (p->first == NULL)
    {
        free(p);
        return NULL;
    }

    p->first->prev = p->first->next = NULL;
    p->num = 0;
    return p;
}

struct Head *Create_Empty_DoubleLinkedListWithHead_1()
{
    struct Head *head = malloc(sizeof(*head));
    head->first = head->last = NULL;
    head->num = 0;
    return head;
}

/*
        从键盘上输入数据创建一条整型数据双向链表
        Create_Input_DoubleLinkedListWithHead:创建一条带头结点的空双向链表

        返回值:
            返回头节点地址
*/
struct Head *Create_Input_DoubleLinkedListWithHead()
{
    // 创建头结点
    struct Head *head = malloc(sizeof(*head));
    if (head == NULL)
        return NULL;
    head->first = head->last = NULL; // 初始化链表的第一个和最后一个节点为NULL
    head->num = 0;                   // 初始化链表节点数量为0

    int x;
    printf("请输入整型数据:");
    scanf("%d", &x);

    // 读取用户输入的整型数据,直到输入为0为止
    while (x != 0)
    {
        // 创建新的节点
        struct Node *p = malloc(sizeof(*p));
        if (p == NULL)
            return NULL;
        p->data = x;    // 将用户输入的数据存储到节点中
        p->next = NULL; // 初始化节点的下一个节点指针为NULL

        // 如果链表为空,则将新节点设置为第一个节点,并更新最后一个节点指针
        if (head->first == NULL)
        {
            head->first = p;
            head->last = p;
            p->prev = NULL; // 第一个节点的前一个节点指针为NULL
        }
        else
        {
            // 如果链表不为空,则将新节点连接到链表的最后一个节点,并更新最后一个节点指针
            head->last->next = p;
            p->prev = head->last;
            head->last = p;
        }
        p->next = NULL;  // 更新新节点的下一个节点指针为NULL
        head->num++;     // 更新链表节点数量
        scanf("%d", &x); // 继续读取用户输入的整型数据
    }
    return head; // 返回创建好的带头结点的双向链表
}

// 判空
bool Is_Head(struct Head *head)
{
    if (head->num == 0 && head->first == NULL && head->last == NULL)
        return true;
    return false;
}

/*
       Print_DoubleLinkedListWithHead:输出一条带头结点的整型双向链表
       @head:要输出的链表的头节点指针

       返回值:
           无
*/
void Print_DoubleLinkedListWithHead(struct Head *head)
{
    if (head == NULL)
        return;
    struct Node *p = head->first;
    printf("=========================\n");
    if (Is_Empty_LinkedListWithHead(head))
    {
        printf("num = %d\n", head->num);
    }
    else
    {
        printf("num = %d, first->data = %d, last->data = %d\n", head->num,
               head->first->data, head->last->data);
    }
    printf("Next:");
    while (p)
    {
        printf("%d ", p->data);
        p = p->next;
    }

    printf("\n");
    printf("Prev:");
    p = head->last;
    while (p)
    {
        printf("%d ", p->data);
        p = p->prev;
    }

    printf("\n");
}

/*
        Insert_node_y:在head指向的带头结点的双向链表中,找到值为x的节点,在其前面增加一个值为y的节点
        如果有多个值为x的节点则在第一个前面增加
        如果没有则增加在最后
        @head:
        @x:
        @y:

        返回值:
            无
*/
struct Head *Insert_node_y(struct Head *head, Elemtype x, Elemtype y)
{
    if (head == NULL)
        return head;
    // 创造新节点保存y
    struct Node *pnew = malloc(sizeof(*pnew));
    pnew->data = y;
    pnew->next = NULL;
    pnew->prev = NULL;

    // 查找
    struct Node *p = head->first; // 遍历指针,从链表的第一个节点开始遍历
    struct Node *pre = NULL;      // 前驱指针,用于记录当前节点的前一个节点
    while (p)
    {
        if (p->data == x)
            break;
        pre = p;
        p = p->next;
    }

    // 增加
    if (p) // 找到x
    {
        if (p == head->first) // x在首节点
        {
            pnew->next = p;
            head->first = pnew;
            p->prev = pnew;
        }
        else // x不在首节点
        {
            pnew->next = p;
            pre->next = pnew;
            p->prev = pnew;
            pnew->prev = pre;
        }
    }
    else // 未找到
    {
        if (Is_Head(head))
            head->first = head->last = pnew; // 首尾节点都指向新节点
        else
        {
            head->last->next = pnew;
            pnew->prev = head->last;
            head->last = pnew;
        }
    }
    head->num++;
    return head;
}

struct Head *Insert_node_y_2(struct Head *head, Elemtype x, Elemtype y)
{
    if (head == NULL)
        return head;

    // 创建新节点保存y
    struct Node *pnew = malloc(sizeof(*pnew)); // 创建新节点并分配内存空间
    pnew->data = y;                            // 设置新节点的数据为y
    pnew->next = NULL;                         // 设置新节点的下一个节点指针为NULL,表示当前节点为链表末尾节点
    pnew->prev = NULL;                         // 设置新节点的前一个节点指针为NULL,表示当前节点为链表首节点

    // 遍历链表查找值为x的节点
    struct Node *p = head->first; // 使用指针p遍历链表,从首节点开始
    while (p)
    {
        if (p->data == x) // 如果当前节点的数据等于x,则表示找到了目标节点
            break;
        p = p->next; // 否则继续向后遍历下一个节点
    }

    // 插入新节点
    if (p) // 如果找到了值为x的节点
    {
        if (p->prev) // 如果x节点不是首节点
        {
            p->prev->next = pnew; // 将新节点插入到x节点之前
            pnew->prev = p->prev;
        }
        else // 如果x节点是首节点
        {
            head->first = pnew; // 更新首节点为新节点
        }
        pnew->next = p; // 更新新节点的下一个节点为x节点
        p->prev = pnew; // 更新x节点的前一个节点为新节点
    }
    else // 如果未找到值为x的节点
    {
        if (head->last) // 如果链表非空
        {
            head->last->next = pnew; // 将新节点插入到链表末尾
            pnew->prev = head->last;
            head->last = pnew; // 更新链表末尾为新节点
        }
        else // 如果链表为空
        {
            head->first = pnew; // 更新首节点为新节点
            head->last = pnew;  // 更新末尾节点为新节点
        }
    }
    head->num++; // 增加链表节点数量
    return head; //
}

/*
       Delete_all_x:在head指向的带头结点的双向链表中,找到值为x的节点,将其删除
   如果有多个值为x的节点则全部删除
       如果没有则不删除
       @head:
       @x:
       @y:

       返回值:
           无
*/
void Delete_all_x(struct Head *head, Elemtype x)
{
    if (head == NULL)
    {
        return;
    }

    struct Node *p = head->first;
    struct Node *pre = NULL;

    while (p)
    {

        // 查找
        while (p)
        {
            if (p->data == x)
                break;
            pre = p;
            p = p->next;
        }

        // 删除
        if (p)
        {
            if (p == head->first) // 如果是首节点
            {
                if (head->first == head->last) // 如果只有一个
                {
                    head->last = NULL;
                }
                head->first = p->next;
                if (head->first != NULL)
                {
                    head->first->prev = NULL;
                }
                p->next = NULL;
                free(p);
                p = head->first;
            }

            else if (p == head->last) // 如果p在尾节点
            {
                head->last = pre;
                pre->next = NULL;
                p->prev = NULL;
                free(p);
                p = NULL;
            }

            else
            {
                pre->next = p->next;
                p->next->prev = pre;
                p->next = NULL;
                p->prev = NULL;
                free(p);
                p = pre->next;
            }
            head->num--;
        }
        printf("-------\n");
    }
}

void Delete_all_x_2(struct Head *head, Elemtype x)
{
    if (head == NULL)
    {
        return; // 如果链表为空,直接返回
    }

    struct Node *p = head->first; // 使用指针p遍历链表,从首节点开始
    struct Node *next = NULL;     // 用于暂存下一个节点
    struct Node *pre = NULL;      // 用于记录当前节点的前一个节点

    while (p != NULL)
    { // 循环查找和删除值为x的节点
        if (p->data == x)
        {                   // 如果当前节点的数据等于x,则删除该节点
            next = p->next; // 先保存下一个节点的指针
            if (p == head->first)
            { // 如果是首节点
                head->first = next;
                if (next != NULL)
                {
                    next->prev = NULL; // 更新新的首节点的前一个节点指针为NULL
                }
                else
                { // 如果只有一个节点
                    head->last = NULL;
                }
            }
            else
            {
                pre->next = p->next; // 将前一个节点的next指针指向下一个节点
                if (next != NULL)
                {
                    next->prev = pre; // 更新下一个节点的prev指针为前一个节点
                }
                else
                {                     // 如果是尾节点
                    head->last = pre; // 更新尾节点为前一个节点
                }
            }
            free(p);     // 释放当前节点的内存空间
            p = next;    // 移动到下一个节点
            head->num--; // 减少链表节点数量的计数器
        }
        else
        {
            pre = p;     // 记录当前节点为前一个节点
            p = p->next; // 移动到下一个节点
        }
    }
}

QM897
关注
  • 9
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
双链表删除节点
Turtle's trail
02-22 6516
编写一个程序，从双链表中移除一个节点，函数的原型如下 int dll_remove(struct NODE *rootp, struct NODE *node); 你可以假设节点数据结构在头文件double_linked_list_node.h文件中定义，函数第一个参数是一个指向包含链表根指针的节点的指针，第二个参数是个指向欲移除的节点的指针，如果链表并不包含欲移除的指针，函数就返回假，否则函数移除该节点并返回真。 遇到链表操作的题目，第一步就是画一个链表图，然后理清指针指向然后再转化成代码
c语言双链表删除节点,C语言实现双向链表删除节点、插入节点、双向输出等操作...
weixin_35070925的博客
05-22 1294
#include#includetypedef struct DoubleLinkedList{int data;struct DoubleLinkedList *pre;struct DoubleLinkedList *next;}DlinkedList_Node;//建立链表DlinkedList_Node* createDLink(){DlinkedList_Node *head,*p,*s...
【数据结构】带头节点双向循环链表
weixin_53269843的博客
11-21 2019
顺序表和链表的区别 带头双向循环链表分析 带头双向循环链表结构： 创建一个节点 哨兵位头节点 打印链表中的值 在pos前插入 删除pos位置的节点 尾插 尾删 头插： 头删 链表元素查找
链表之带头节点双向循环链表的实现
qq_64128135的博客
01-27 935
一： 链表分为八大类，此篇讲述的带头节点双向循环链表的实现； 此类链表物理结构如下图： 每个节点内有2个指针，分别指向前一个节点和下一个节点； 当链表没有内容时头节点如下所示： 头节点的好处是进行插入或删除第一个节点时不用考虑特殊情况； 对比单链表，带头链表的好处时进行头插头删时不必使用二级指针； 二、实现： typedef struct LIST { struct LIST* prev; s...
双向链表（带头结点）
bentao1997719的博客
05-24 844
双链表 - 两个方向 带头节点 节点的定义 typedef int data_t; typedef struct link_node{ data_t data; //数据域，用来保存数据 struct link_node *next; //保存后面一个节点的地址 struct link_node *pre; //用来保存前一个节点的地址 }link_node_t; 创建带头结点的双链表 link_node_t *create_link_list(void) { //定义头结点，在堆上分配
数据结构 - 链表 - 头节点的意义
qazw9600的专栏
08-12 9840
说明 初学数据结构时，对于链表定义一个空数据的头结点表示不理解，不明白其作用，甚至有时为了节省内存空间而去掉该节点，但是头结点是有意义的。 头结点示意图： 缺点 多定义了一个结点，多占用了一个结点的内存。 改善方式：可以采用linux kernel中的list实现方式（结点中只包含结点指针不包含结点数据），减少头节点的内存占用。 优点 单链表或双链表删除或插入节点时，如果没有头结点，处理有两种情况： 操作的对象是第一个结点，相对于其它情况，需要额外更改链表入口指针。 操作的对象不是第一个结
C语言——链表（带头节点与不带头节点）
m0_73771309的博客
07-18 1238
链表是一种常见的线性数据结构，它由一系列的节点组成，每个节点包含两部分：数据和指向下一个节点的指针。每个节点可以在内存中不连续地分布，通过指针将它们串联在一起。下面呢，进入正题！！！首先呢，我们先看这张图！这是带头节点，带头节点的链表是在链表头部添加了一个额外的节点，该节点不存储任何数据，只是作为链表的起始位置。带头节点的链表中，头节点的下一个节点才是实际存储数据的第一个节点。
双链表中插入节点（C语言实现）
zsx0728的博客
07-15 8529
文章目录1. 相关背景介绍1.1 双链表概念1.2 双链表的优势与劣势1.3 双链表插入节点的位置2. 不同位置插入数据2.1 在DLL的前端添加节点2.2 在给定节点之前添加节点2.3 在DLL的末尾添加节点2.4 在给定节点之后添加节点3. 综合示例参考文献 1. 相关背景介绍 1.1 双链表概念     相比SLL（singly linked list，单链表），DLL（Doubly Linked List，双链表）多了一个名为 previous pointer （Prev）的指针，该指针指向前一节点
【数据结构与算法】双向链表(添加节点、更新节点、删除节点、打印链表)
Bulut0907
09-20 1917
双向链表是一种复杂类型的链表，它的节点包含指向数列中前一个节点和下一个节点的指针。双向链表每个节点包含data域、pre域(指向上一个节点)、next域(指向下一个节点)。所以双向链表可以向前或向后查找双向链表可以双向遍历，既可以从头遍历到尾，也可以从尾遍历到头，有效解决了单向链表的缺点，实际开发中双向链表应用比单向链表多，但是实现较困难。我们下面来看下双向链表的简单实现。
双向链表删除指定节点，JAVA实现
bigbearxyz的博客
02-24 1788
构造双向链表，删除指定节点： public class NodeTest { static class MyNode { int val; MyNode preNode; MyNode nextNode; public MyNode(int val, MyNode preNode, MyNode nextNode) { this.val = val; this.preNode =
创建双链表的节点、插入节点到双链表头部、打印双链表和删除所有节点的功能
07-09
createNode 函数，用于创建一个新的双链表节点。 insertAtBeginning 函数现在将新节点插入到链表的开头，并正确地更新前驱和后继指针。 printList 函数用于遍历并打印双链表中的数据。 deleteList 函数，用于遍历双...
PHP实现双链表删除与插入节点的方法示例
10-19
双链表是一种数据结构，其中每个节点包含两个指针，一个指向前一个节点（prev），另一个指向后一个节点（next）。这使得我们可以从前向后和从后向前遍历链表。 首先，我们定义一个`Node`类，用于表示链表中的单个...
C语言实现的双链表功能完整示例
08-27
C语言实现的双链表功能完整示例 本文主要介绍了C语言实现的双链表功能，结合完整实例形式分析了基于C语言实现的双链表定义、添加、删除、排序等相关操作实现技巧。 一、双链表的定义 在C语言中，双链表的定义主要...
带头节点的双向链表
10-29
带头节点的双向链表，顾名思义，是在链表的开头添加了一个特殊的节点，称为头节点。头节点不存储实际的数据，而是作为链表的起点，它的 prev 指针通常为空，next 指针则指向链表的第一个实际数据节点。这样的设计有...
Java实现双链表互相交换任意两个节点的方法示例
08-28
双链表也称为双向链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。因此，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环...
函数模板与类模板
程序员_小兵
07-12 1549
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
基于Big-Bang-Big-Crunch(BBBC)算法的目标函数最小值计算matlab仿真
熟悉python,matlab,C,C++,JAVA等
07-12 359
BBBC算法的核心思想模拟了宇宙从大爆炸（Big Bang）开始，经历扩张，再到可能的大收缩（Big Crunch）的过程，以此类比于在解空间中从初始分散的解集出发，通过一系列搜索过程逐步集中并接近最优解的过程。：一个简化的聚集方法可以是xi′′​=xbest​+β⋅(xi′​−xbest​)，其中xbest​是最优解，β是一个小于1的收缩因子，控制收缩速度。：每个解xi​依据一定的规则在解空间中移动，这个移动可以是随机的，也可以基于某种策略，比如基于目标函数梯度的方向或者利用当前解与其他解的相对位置。
树状数组（Binary Indexed Tree, BIT）
qq_73702550的博客
07-12 353
树状数组（Binary Indexed Tree, BIT），也称为 Fenwick Tree，是一种用于高效处理数组前缀和查询和单点更新的数据结构。它能够在 (O(\log n)) 时间内完成单点更新和前缀和查询操作。
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
最新发布
m0_74586426的博客
07-12 753
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
双向链表交换相邻节点
08-05
双向链表交换相邻节点可以有多种实现方法。根据引用中的递归方法，我们可以利用递归来实现双向链表交换相邻节点的操作。具体步骤如下： 1. 首先，我们需要设置递归的终止条件。当链表为空或只有一个节点时，无需...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值