数据结构之双向链表

最新推荐文章于 2024-10-13 22:37:06 发布
最新推荐文章于 2024-10-13 22:37:06 发布
阅读量43 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47225948/article/details/132917070
版权

数据结构之双向链表


一、C 双向链表源码及详解

双向链表是一种常用的链式数据结构，它和普通链表不同的是，双向链表中的每个节点不仅包含指向下一个节点的指针，还包含指向前一个节点的指针。

以下是 C 语言实现双向链表的源代码。

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

struct node {
    int data;
    struct node* prev;
    struct node* next;
};

struct node* head = NULL;
struct node* tail = NULL;
int count = 0;

// 在双向链表末尾添加一个节点
void append(int data) {
    struct node* new_node = malloc(sizeof(struct node));
    new_node->data = data;
    new_node->next = NULL;

    if (head == NULL) {
        new_node->prev = NULL;
        head = tail = new_node;
    }
    else {
        new_node->prev = tail;
        tail->next = new_node;
        tail = new_node;
    }

    count++;
}

// 在双向链表指定位置插入一个节点
void insert(int data, int pos) {
    if (pos < 0 || pos > count) {
        printf("Invalid position\n");
        return;
    }

    struct node* new_node = malloc(sizeof(struct node));
    new_node->data = data;

    if (pos == 0) {
        new_node->prev = NULL;
        new_node->next = head;
        head->prev = new_node;
        head = new_node;
    }
    else if (pos == count) {
        new_node->prev = tail;
        new_node->next = NULL;
        tail->next = new_node;
        tail = new_node;
    }
    else {
        struct node* tmp = head;
        int i;
        for (i = 0; i < pos-1; i++) {
            tmp = tmp->next;
        }
        new_node->prev = tmp;
        new_node->next = tmp->next;
        tmp->next->prev = new_node;
        tmp->next = new_node;
    }

    count++;
}

// 从双向链表中移除一个节点
void remove_node(int pos) {
    if (pos < 0 || pos >= count) {
        printf("Invalid position\n");
        return;
    }

    if (pos == 0) {
        struct node* tmp = head;
        head = head->next;
        if (head != NULL) {
            head->prev = NULL;
        }
        else {
            tail = NULL;
        }
        free(tmp);
    }
    else if (pos == count-1) {
        struct node* tmp = tail;
        tail = tail->prev;
        tail->next = NULL;
        free(tmp);
    }
    else {
        struct node* tmp = head;
        int i;
        for (i = 0; i < pos; i++) {
            tmp = tmp->next;
        }
        tmp->prev->next = tmp->next;
        tmp->next->prev = tmp->prev;
        free(tmp);
    }

    count--;
}

// 打印双向链表
void print_list() {
    struct node* tmp = head;
    while (tmp != NULL) {
        printf("%d ", tmp->data);
        tmp = tmp->next;
    }
    printf("\n");
}

int main() {
    append(1);
    append(2);
    append(3);
    insert(4, 0);
    insert(5, 2);
    insert(6, 5);
    remove_node(3);
    print_list();

    return 0;
}

双向链表的实现主要包括以下几个部分：

  1. 定义节点结构体，包括存储数据、指向前一个节点的指针和指向后一个节点的指针。

  2. 定义全局变量 head 和 tail，它们分别指向双向链表的头节点和尾节点。

  3. 定义操作双向链表的函数，包括添加节点、在指定位置插入节点、移除节点和打印双向链表。

在添加节点时，如果链表还没有任何元素，将新节点设为 head 和 tail；否则在链表末尾添加节点。

在插入节点时，需要处理三种情况：插入到链表头部、插入到链表尾部和插入到链表中间。在链表头部插入节点时，需要将 head 指向新节点，并将新节点的 prev 指针设为 NULL；在链表尾部插入节点时，需要将 tail 指向新节点，并将新节点的 next 指针设为 NULL；在链表中间插入节点时，需要找到待插入位置的前一个节点，然后将新节点插入到前一个节点和后一个节点之间。

在移除节点时，需要处理三种情况：移除链表头部节点、移除链表尾部节点和移除链表中间节点。在移除链表头部节点时，将 head 指向下一个节点，并将新头节点的 prev 指针设为 NULL；在移除链表尾部节点时，将 tail 指向上一个节点，并将新尾节点的 next 指针设为 NULL；在移除链表中间节点时，需要找到待移除节点的前一个节点和后一个节点，然后将前一个节点的 next 指针设为后一个节点，后一个节点的 prev 指针设为前一个节点。

最后，打印双向链表时，从头节点开始遍历链表，并输出每个节点的数据。

在这里插入图片描述


二、C++ 双向链表源码及详解

以下是 C++ 双向链表的基本实现代码及说明。双向链表的节点除了存储数据外，还需要存储前驱节点和后继节点，这样才能实现双向遍历。

#include <iostream>

using namespace std;

// 定义双向链表节点结构体
struct Node {
    int data; // 数据域
    Node* pre; // 指向前驱节点的指针
    Node* next; // 指向后继节点的指针
};

// 定义双向链表类
class DoublyLinkedList {
private:
    Node* head; // 头节点指针
    Node* tail; // 尾节点指针
public:
    DoublyLinkedList() {
        head = nullptr;
        tail = nullptr;
    }

    // 插入节点：在链表尾部插入
    void insert(int value) {
        Node* node = new Node;
        node->data = value;
        node->pre = tail;
        node->next = nullptr;

        if (tail) {
            tail->next = node;
        }
        tail = node;
        if (!head) {
            head = node;
        }
    }

    // 删除节点：从链表中删除指定节点
    void remove(Node* node) {
        if (node == head && node == tail) {
            head = nullptr;
            tail = nullptr;
        } else if (node == head) {
            head = head->next;
            head->pre = nullptr;
        } else if (node == tail) {
            tail = tail->pre;
            tail->next = nullptr;
        } else {
            node->pre->next = node->next;
            node->next->pre = node->pre;
        }
        delete node;
    }

    // 遍历节点：从头节点开始遍历
    void traverse() {
        Node* node = head;
        while (node) {
            cout << node->data << " ";
            node = node->next;
        }
        cout << endl;
    }
};

主要方法的说明：

  • insert：在链表尾部插入一个新节点。该方法首先创建一个新节点，然后让新节点成为当前尾节点（如果链表非空，则将当前尾节点的 next 指针指向新节点），并将链表尾指针 tail 指向新节点。如果链表为空，则新节点就是头节点，也将链表头指针 head 指向新节点。
  • remove：删除链表中的指定节点。该方法判断要删除的节点 node 是否为头节点，尾节点或者头尾节点。如果 node 是头尾节点，则直接将头尾指针设为空；如果 node 是头节点，则将头指针 head 指向 node 的下一个节点，并将该节点的前驱节点指针设置为空；如果 node 是尾节点，则将尾指针 tail 指向 node 的前驱节点，并将该节点的后继节点指针设置为空；否则，将 node 的前驱节点的 next 指针指向 node 的后继节点，将 node 的后继节点的前驱节点指针指向 node 的前驱节点。
  • traverse：遍历链表。该方法从头节点开始遍历链表，并将每个节点的数据域打印出来。

以上是双向链表的基本实现代码和说明。在实际应用中，双向链表的操作包括查询某个节点、在任意位置插入节点等，这里并未详细说明，读者可以根据需要进行扩展。


三、java 双向链表源码及详解

双向链表是一种链式数据结构，每个节点包含两个指针，一个指向前一个节点，一个指向后一个节点。双向链表可以从前向后或从后向前遍历，因此具有灵活性。Java的LinkedList类就是基于双向链表实现的。

下面是一份基于Java实现的双向链表源码及详解：

public class DoublyLinkedList<T> {
    private Node<T> head;
    private Node<T> tail;
    private int size;

    private class Node<T> {
        private T data;
        private Node<T> prev;
        private Node<T> next;

        public Node(T data, Node<T> prev, Node<T> next) {
            this.data = data;
            this.prev = prev;
            this.next = next;
        }
    }

    public DoublyLinkedList() {
        head = null;
        tail = null;
        size = 0;
    }

    public boolean isEmpty() {
        return size == 0;
    }

    public int size() {
        return size;
    }

    public void addFirst(T data) {
        Node<T> newNode = new Node<>(data, null, head);
        if (isEmpty()) {
            tail = newNode;
        } else {
            head.prev = newNode;
        }
        head = newNode;
        size++;
    }

    public void addLast(T data) {
        Node<T> newNode = new Node<>(data, tail, null);
        if (isEmpty()) {
            head = newNode;
        } else {
            tail.next = newNode;
        }
        tail = newNode;
        size++;
    }

    public T removeFirst() {
        if (isEmpty()) {
            throw new NoSuchElementException();
        }
        T removedData = head.data;
        if (size == 1) {
            head = null;
            tail = null;
        } else {
            head = head.next;
            head.prev = null;
        }
        size--;
        return removedData;
    }

    public T removeLast() {
        if (isEmpty()) {
            throw new NoSuchElementException();
        }
        T removedData = tail.data;
        if (size == 1) {
            head = null;
            tail = null;
        } else {
            tail = tail.prev;
            tail.next = null;
        }
        size--;
        return removedData;
    }

    public T get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException();
        }
        Node<T> current = head;
        for (int i = 0; i < index; i++) {
            current = current.next;
        }
        return current.data;
    }

    public void add(int index, T data) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException();
        }
        if (index == 0) {
            addFirst(data);
        } else if (index == size) {
            addLast(data);
        } else {
            Node<T> current = head;
            for (int i = 0; i < index - 1; i++) {
                current = current.next;
            }
            Node<T> newNode = new Node<>(data, current, current.next);
            current.next.prev = newNode;
            current.next = newNode;
            size++;
        }
    }

    public T remove(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException();
        }
        if (index == 0) {
            return removeFirst();
        } else if (index == size - 1) {
            return removeLast();
        } else {
            Node<T> current = head;
            for (int i = 0; i < index; i++) {
                current = current.next;
            }
            T removedData = current.data;
            current.prev.next = current.next;
            current.next.prev = current.prev;
            size--;
            return removedData;
        }
    }

    public int indexOf(T data) {
        Node<T> current = head;
        int index = 0;
        while (current != null) {
            if (current.data == data || current.data.equals(data)) {
                return index;
            }
            current = current.next;
            index++;
        }
        return -1;
    }

    public boolean contains(T data) {
        return indexOf(data) != -1;
    }

    public void clear() {
        head = null;
        tail = null;
        size = 0;
    }

    public String toString() {
        if (isEmpty()) {
            return "[]";
        }
        StringBuilder sb = new StringBuilder("[");
        Node<T> current = head;
        while (current.next != null) {
            sb.append(current.data).append(", ");
            current = current.next;
        }
        sb.append(current.data).append("]");
        return sb.toString();
    }
}

该双向链表类包含了基本的操作方法，如添加、删除、获取等，下面是各个方法的详细描述：

  • addFirst(T data)：在链表头部添加一个元素，时间复杂度为O(1)；
  • addLast(T data)：在链表尾部添加一个元素，时间复杂度为O(1)；
  • removeFirst()：删除链表头部的元素并返回它的值，时间复杂度为O(1)；
  • removeLast()：删除链表尾部的元素并返回它的值，时间复杂度为O(1)；
  • get(int index)：返回链表中指定位置的元素，时间复杂度为O(n)；
  • add(int index, T data)：在链表中指定位置处插入一个元素，时间复杂度为O(n)；
  • remove(int index)：删除链表中指定位置处的元素并返回它的值，时间复杂度为O(n)；
  • indexOf(T data)：返回链表中第一个匹配到的元素的位置，时间复杂度为O(n)；
  • contains(T data)：判断链表中是否包含指定元素，时间复杂度为O(n)；
  • clear()：清空链表中的所有元素，时间复杂度为O(1)；
  • toString()：将链表转为字符串形式输出。

总的来说，双向链表的实现较单向链表稍微复杂一些，需要维护prev指针和next指针，但是双向链表的灵活性更高，可以支持从前向后或从后向前遍历，因此在某些场景下应用效果更好。

在这里插入图片描述



躺平的小懒猫
关注
专栏目录
C#数据结构之双向链表(DbLinkList)实例详解
09-03
在C#中，双向链表（Double-Linked List，简称DbLinkList）是一种重要的数据结构，它允许在列表中的每个元素都有两个链接：一个指向前一个元素，另一个指向后一个元素。这种数据结构使得在链表中进行前向和后向遍历变...
Python数据结构之双向链表的定义与使用方法示例
09-20
Python中的双向链表是一种线性数据结构，与单链表相比，它在每个节点中不仅包含指向下一个节点的指针，还包含一个指向前一个节点的指针。这使得双向链表可以在正向和反向两个方向上进行遍历，提高了操作的灵活性。 ...
JavaScript数据结构之双向链表定义与使用方法示例
10-19
在JavaScript中，数据结构是构建高效算法的基础，而双向链表是一种重要的线性数据结构。本文将深入探讨双向链表的定义、工作原理以及如何在JavaScript中实现和使用它。 双向链表，顾名思义，是每个节点不仅包含指向...
JavaScript数据结构之双向链表和双向循环链表的实现
10-18
在JavaScript中，数据结构是构建复杂程序的基础，其中双向链表和双向循环链表是两种重要的线性数据结构。本文将深入探讨这两种链表的实现原理，并通过代码示例进行详细解析。 首先，双向链表（Doubly Linked List）...
《C++中栈的实现：探索高效数据结构》
xy520521的博客
10-13 291
当向栈中添加元素时，创建一个新的节点，将其数据设置为要添加的元素，并将其指向下一个节点设置为当前的栈顶节点，然后将栈顶指针指向新节点。当从栈中删除元素时，将栈顶指针指向当前栈顶节点的下一个节点，并释放原来栈顶节点的内存。首先，数组的大小是固定的，一旦栈的大小超过了数组的容量，就需要进行复杂的扩容操作。其次，数组实现的栈在内存中的分配是连续的，可能会导致内存碎片的问题。此外，链表实现的栈在内存中的分配是不连续的，不会产生内存碎片。但是，链表实现的栈在进行插入和删除操作时需要进行指针的操作，相对来说比较复杂。
数据结构和算法简介
知其然 知其所以然
10-07 843
所谓算法，其实就是定义良好的计算过程，取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。一个算法所花费的时间与其中语句的执行次数成正比，但是算法中的语句往往比较多，所以，我们选择算法中的基本操作的执行次数，为算法的时间复杂度。空间复杂度也是一个数学表达式，是对一个算法在运行过程中临时额外占用存储空间大小的度量。我们可以这样理解，解决同一个问题，可能有不同的算法， 但是不同的算法都不能避免解决该问题本身所需要的存储空间。
数据结构之链表
最新发布
2301_79562326的博客
10-13 515
使用“快慢指针”方法，快指针一次走两步，慢指针一次走一步。如果链表有环，快慢指针会在某一点相遇。：要求将单向链表反转，使得原来的头节点变为尾节点，尾节点变为头节点。遍历链表就是从头节点开始，依次访问每个节点，直到。（对于单向链表）或循环到头节点（对于循环链表）。：将两个已经排序的链表合并为一个新的有序链表。// 删除头节点示例。
数据结构：红黑树
2303_78940834的博客
10-13 1019
前面我们介绍了AVL树来解决搜索二叉树不平衡的问题，今天我们带来一种新的解决方案，同时，这种解决方案在实践中比AVL树更常用，这种数据结构就是红黑树。
数据结构-顺序表
m0_60633015的博客
10-13 125
静态顺序表：使用定长数组存储元素.缺点是 动态顺序表：使用动态开辟的数组存储元素.依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。顺序表: 顺序表是用一段。顺序表的指定位置插入。顺序表指定位置的删除。
【数据结构】顺序表应用---删除偶数
2301_79982543的博客
10-10 332
如果两个偶数是连在一起的，那移动过后第i位依旧是偶数，所以需要i--检查再次检查第i位的情况 ，如图所示。你的任务是创建一个顺序表，输入多个整数存入表中，删除其中的偶数，然后输出表中的所有数据。今天的分享就到这里啦~~希望对您有所帮助！下次再见啦~~ヾ(￣▽￣)Bye~Bye~样例输入： 10 34 23 9 10 10 17 31 32 1 15。采用顺序表存储一批整数，去掉其中所有的偶数。第2行：顺序表中的数据，每个整数用空格隔开。第1行：顺序表中数据个数。第2行：输入n个整数。
手撕数据结构 —— 单链表（C语言讲解）
知其然 知其所以然
10-10 1225
链表是一种利用不连续的内存空间存储数据元素的数据结构，并且元素之间可以不按顺序进行存储。正是因为链表不按顺序存储，要想找到下一个数据就需要记录下一个数据的地址，因此，链表中的数据是包含在一个结构体中，我们通常称这个结构体变量为结点。最后一个结点没有下一个结点，就指向空。链表的特点是按需申请和释放。链表逻辑示意图如下：我们申请结点的时候，一般是使用动态内存管理的函数申请内存空间（malloc、realloc），这些函数是从堆上申请空间的。
NR PDSCH资源分配与DM-RS和PT-RS参考信号
WHS-_-2022的博客
10-13 620
本文的写作目的是为了汉化MATLAB关于 NR PDSCH 资源分配的，帮助大家更快的掌握PDSCH中资源的分配问题。来张时频资源图镇楼。
《重生到现代之从零开始的数据结构生活》—— 顺序表1
yttandb的博客
10-10 808
顺序表
leetcode数据结构刷题
m0_62995834的博客
10-13 126
这样逻辑简单又好懂，哈哈哈。
【Redis原理】数据结构(上)
2301_78320637的博客
10-10 1210
Dict。
C、C++常用数据结构：树
S13352784013的博客
10-13 804
C、C++常用数据结构：树
【JAVA-数据结构】ArrayList的具体使用
Mr_star_galaxy的博客
10-10 286
接着上面的继续讲解，今天进行关于ArrayList的具体使用，帮助大家加强理解。
2024/10/9 数据结构打卡
m0_63504902的博客
10-10 247
1 利用快速排序算法，将元素从小到大进行排序，由题意可知，将a1划分成数组下标0，n-1/2（闭区间）和（n-1/2，n)开区间，满足了题意。时间复杂度 nlogn 空间复杂度o1。
数据结构-双向链表前插操作详解
"双向链表的前插操作算法及其在数据结构中的重要性" 在计算机科学中，数据结构是研究如何高效地存储和处理数据的重要领域。清华大学严蔚敏教授的《数据结构》C语言版中详细阐述了各种数据结构及其操作，其中包括...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值