【数据结构】双向链表和循环链表

1、引言

​ 通过这种链式存储，不需要像顺序表那样一次性申请一段连续的空间，而是只需要单独为结点申请内存空间，同时在插入和删除的速度上也比顺序表轻松，不过有一个问题就说，如果想要操作某个结点，比如删除或插入，那么由于单链表的性质，只能先去找到它的前驱结点，才能前进。那我们如何解决这个麻烦的问题？

2、双向链表

​ 双向链表结点不仅保存指向后续结点的指针，同时也保存指向前驱结点的指针，这样，无论在哪个结点，我们都能够快速找到对应的前驱结点。

代码实现:

定义结构体

typedef int E; // 定义元素类型别名 E，代表整数类型

struct ListNode {
    E element;             // 节点中存储的元素
    struct ListNode *next; // 指向下一个节点的指针
    struct ListNode *prev; // 指向上一个节点的指针
};

typedef struct ListNode *Node; // 定义节点指针类型别名 Node，指向 ListNode 结构体的指针

初始化链表

/**
 * 初始化双向链表
 * 
 * @param head 头节点指针
 */
void initList(Node head) {
    head->next = head->prev = NULL; // 将头节点的 next 和 prev 指针置空，表示链表为空
}

插入操作

双向链表的插入操作，会比单链表更加繁琐

首先我们需要考虑后继结点，当新结点插入后，新结点的后继结点就是原本在此位置上的结点，所以我们可以先将待插入结点的后继指针指向此位置的结点

由于是双向链表，所以我们需要将原来在此位置上的结点的前驱指针指向新的结点

接下来再把前驱结点的后继指针修改为新的结点

最后再把新结点的前驱指针指向前驱结点

代码实现：

#include <stdbool.h>
#include <stdlib.h> // for malloc

/**
 * 向双向链表中插入元素
 * 
 * @param head    头节点指针
 * @param element 要插入的元素
 * @param index   插入位置的索引（从1开始）
 * @return        插入成功返回 true，否则返回 false
 */
bool insertList(Node head, E element, int index) {
    if (index < 1) // 如果索引小于1，则插入无效
        return false;

    while (--index) { // 定位到插入位置的前一个节点
        head = head->next;
        if (head == NULL) // 若链表长度不足，插入失败
            return false;
    }

    Node node = (Node)malloc(sizeof(struct ListNode)); // 创建新节点
    if (node == NULL) // 内存分配失败，插入失败
        return false;

    node->element = element; // 设置新节点的元素值

    if (head->next != NULL) { // 如果插入位置不是尾节点
        node->next = head->next; // 将新节点的下一个节点指针指向原插入位置节点的下一个节点
        head->next->prev = node; // 将原插入位置节点的下一个节点的前一个节点指针指向新节点
    } else {
        node->next = NULL; // 如果插入位置是尾节点，则新节点的下一个节点指针为空
    }

    head->next = node; // 将原插入位置节点的下一个节点指针指向新节点
    node->prev = head; // 将新节点的前一个节点指针指向原插入位置节点

    return true; // 插入成功
}

删除操作

只需要将前驱结点和后继结点的指向修改即可

代码实现：

/**
 * 从双向链表中删除指定位置的节点
 * 
 * @param head  头节点指针
 * @param index 要删除的节点位置的索引（从1开始）
 * @return      删除成功返回 true，否则返回 false
 */
bool deleteList(Node head, int index) {
    if (index < 1) // 如果索引小于1，则删除无效
        return false;

    while (--index) { // 定位到要删除节点的前一个节点
        head = head->next;
        if (head == NULL) // 若链表长度不足，删除失败
            return false;
    }

    if (head->next == NULL) // 要删除的节点不存在，删除失败
        return false;

    Node tmp = head->next; // 将要删除的节点保存到临时变量中
    if (head->next->next) { // 如果要删除的节点不是尾节点
        head->next = head->next->next; // 将要删除节点的前一个节点指针指向要删除节点的下一个节点
        head->next->prev = head; // 将要删除节点的下一个节点的前一个节点指针指向要删除节点的前一个节点
    } else {
        head->next = NULL; // 如果要删除的节点是尾节点，则将前一个节点的下一个节点指针置空
    }

    free(tmp); // 释放要删除节点的内存空间
    return true; // 删除成功
}

3、循环链表

​ 循环链表实际上和前面我们讲的链表是一样的，但它的最后一个结点是与头结点相连的，双向链表和单向链表都可以做成这样的环形结构，以单链表为例：

​ 这种类型的链表实际上与普通链表的唯一去吧就是在于最后是否连接到头结点，因此循环链表支持从任意一个结点出发都可以达到任何的结点，而普通链表则只能从头结点出发才能到达任意结点