数据结构中双向循环链表的基本操作

已于 2024-08-14 04:51:16 修改
阅读量846 收藏 22
点赞数 18
分类专栏： 数据结构和算法 文章标签： 数据结构 链表 算法
于 2024-07-10 06:31:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TENET123/article/details/140191830
版权

文章目录

1. 概念

2. 区别

2.1 结构上的区别

2.2 访问方式区别

2.3 优缺点对比

3. 流程

4. 基本操作

节点和结构定义

初始化单向循环链表

插入节点

删除节点

获取指定位置的元素

修改指定位置的元素

释放单向循环链表的内存

打印所有元素

5. 代码示例

1. 概念

双向循环链表是一种链表数据结构，其中每个节点包含指向前一个节点和下一个节点的指针。与普通双向链表不同，双向循环链表的最后一个节点的后继指针指向头节点，第一个节点的前驱指针指向尾节点，形成一个环。

双向循环链表节点定义

每个节点包含三个部分：数据域、前驱指针域和后继指针域。

typedef struct DNode {
    int data;             // 数据域，存储节点的值
    struct DNode *prev;   // 前驱指针域，指向前一个节点
    struct DNode *next;   // 后继指针域，指向后一个节点
} DNode;

双向循环链表结构定义

双向循环链表包含一个头指针和链表中的节点个数。

typedef struct {
    DNode *head; // 指向双向循环链表的头节点
    size_t size; // 双向循环链表中的节点个数
} DoublyCircularLinkedList;

2. 区别

2.1 结构上的区别

双向链表（Doubly Linked List）：

  • 每个节点包含一个数据域、一个指向前一个节点的指针和一个指向下一个节点的指针。
  • 头节点的前驱指针指向 NULL，尾节点的后继指针指向 NULL。
  • 只能从头节点到尾节点单向遍历，也可以从尾节点到头节点单向遍历。

双向循环链表（Doubly Circular Linked List）：

  • 每个节点也包含一个数据域、一个指向前一个节点的指针和一个指向下一个节点的指针。
  • 头节点的前驱指针指向尾节点，尾节点的后继指针指向头节点，形成一个环。
  • 可以从任意节点开始遍历，最终会回到该节点。

2.2 访问方式区别

双向链表：

  • 可以从头节点向尾节点单向遍历，也可以从尾节点向头节点单向遍历。

双向循环链表：

  • 可以从任意节点开始双向遍历，最终会回到该节点，因此在循环中进行操作时更加方便。

2.3 优缺点对比

双向链表的优缺点

优点：

  1. 双向遍历：可以从任一节点向前和向后遍历。
  2. 删除操作更高效：在已知节点的情况下，删除节点时不需要知道其前驱节点，因为可以通过节点本身直接访问其前驱节点和后继节点。

缺点：

  1. 实现和维护复杂：比单向链表复杂，需要处理更多的指针操作。
  2. 内存占用较大：每个节点包含两个指针，内存占用较单向链表多。

双向循环链表的优缺点

优点：

  1. 双向遍历和循环遍历：不仅可以双向遍历，还可以从任一节点循环遍历。
  2. 删除操作更高效：同双向链表，删除节点时不需要知道其前驱节点。
  3. 循环访问方便：适合需要循环访问数据的应用场景，如约瑟夫环问题。

缺点：

  1. 实现和维护更复杂：需要处理更多的指针操作以及头节点和尾节点的循环链接。
  2. 内存占用较大：每个节点包含两个指针，内存占用较单向链表多。

3. 流程

初始化单向循环链表：

  • 设置头指针为NULL。
  • 设置节点个数为0。

插入新节点：

  • 判断插入位置是否是0。
  • 如果是0，进一步判断链表是否为空：
    • 如果链表为空，新节点指向自己，头指针指向新节点。
    • 如果链表不为空，找到尾节点，新节点指向头节点，头指针指向新节点，尾节点指向新节点。
  • 如果插入位置不是0，找到插入位置的前一个节点，新节点指向前一个节点的后继节点，前一个节点指向新节点。
  • 节点个数加1。

删除节点：

  • 判断删除位置是否是0。
  • 如果是0，保存头节点，进一步判断链表是否只有一个节点：
    • 如果链表只有一个节点，头指针置为NULL。
    • 如果链表有多个节点，找到尾节点，头指针指向头节点的后继节点，尾节点指向新头节点。
  • 如果删除位置不是0，找到删除位置前一个节点，保存要删除的节点，前一个节点指向要删除节点的后继节点。
  • 释放被删除的节点，节点个数减1。

获取指定位置的元素：

  • 判断索引是否合法，如果不合法返回无效索引。
  • 从头节点开始遍历，遍历到目标位置节点，返回节点数据。

修改指定位置的元素：

  • 判断索引是否合法，如果不合法忽略位置。
  • 从头节点开始遍历，遍历到目标位置节点，修改节点数据。

释放单向循环链表内存：

  • 判断链表是否为空，如果为空直接返回。
  • 从头节点开始遍历，保存下一个节点，释放当前节点，继续遍历，直到回到头节点。
  • 头指针置为NULL，节点个数置为0。

4. 基本操作

下面是详细介绍单向循环链表实现中每个函数的功能、参数、操作步骤

节点和结构定义

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

// 单向循环链表节点结构定义
typedef struct Node {
    int data;           // 节点存储的数据
    struct Node *next;  // 指向下一个节点的指针
} Node;

// 单向循环链表结构定义
typedef struct {
    Node *head;         // 单向循环链表头节点指针
    size_t size;        // 单向循环链表中的节点个数
} CircularLinkedList;

初始化单向循环链表

// 初始化单向循环链表
void initCircularLinkedList(CircularLinkedList *list) {
    list->head = NULL; // 初始化头节点为空
    list->size = 0;    // 初始化节点个数为0
}
  • 功能：初始化一个空的单向循环链表。
  • 参数：CircularLinkedList *list，指向需要初始化的链表结构。
  • 操作：
    • 将链表的头节点指针 head 设置为 NULL。
    • 将链表的节点个数 size 设置为 0。

插入节点

// 在指定位置插入元素
void insertAt(CircularLinkedList *list, size_t index, int element) {
    if (index > list->size) {
        return; // 忽略无效的插入位置
    }

    Node *newNode = (Node *)malloc(sizeof(Node)); // 创建新节点
    newNode->data = element;

    if (index == 0) { // 插入位置是头节点
        if (list->head == NULL) { // 如果链表为空
            newNode->next = newNode;
            list->head = newNode;
        } else {
            Node *tail = list->head;
            while (tail->next != list->head) {
                tail = tail->next;
            }
            newNode->next = list->head;
            list->head = newNode;
            tail->next = newNode;
        }
    } else {
        Node *prevNode = list->head;
        for (size_t i = 0; i < index - 1; i++) {
            prevNode = prevNode->next;
        }
        newNode->next = prevNode->next;
        prevNode->next = newNode;
    }

    list->size++; // 更新节点个数
}
  • 功能：在指定位置插入新节点。
  • 参数：
    • CircularLinkedList *list，指向链表结构。
    • size_t index，插入位置的索引。
    • int element，插入节点的值。
  • 操作：
    • 检查插入位置是否合法，如果不合法则直接返回。
    • 创建一个新节点并赋值。
    • 如果插入位置是头节点：
      • 如果链表为空，设置新节点的 next 指针指向自己，并将 head 指针指向新节点。
      • 如果链表不为空，找到尾节点，设置新节点的 next 指针指向头节点，将 head 指针指向新节点，并更新尾节点的 next 指针指向新节点。
    • 如果插入位置不是头节点，找到插入位置的前一个节点，设置新节点的 next 指针指向前一个节点的后继节点，并更新前一个节点的 next 指针指向新节点。
    • 更新链表的节点个数。

删除节点

// 删除指定位置的元素并返回被删除的元素
int deleteAt(CircularLinkedList *list, size_t index) {
    if (index >= list->size) {
        return -1; // 忽略无效的删除位置
    }

    int deletedElement;

    if (index == 0) { // 删除位置是头节点
        Node *temp = list->head;
        if (list->head->next == list->head) { // 如果链表只有一个节点
            list->head = NULL;
        } else {
            Node *tail = list->head;
            while (tail->next != list->head) {
                tail = tail->next;
            }
            list->head = temp->next;
            tail->next = list->head;
        }
        deletedElement = temp->data;
        free(temp); // 释放被删除节点的内存
    } else {
        Node *prevNode = list->head;
        for (size_t i = 0; i < index - 1; i++) {
            prevNode = prevNode->next;
        }
        Node *temp = prevNode->next;
        prevNode->next = temp->next;
        deletedElement = temp->data;
        free(temp); // 释放被删除节点的内存
    }

    list->size--; // 更新节点个数
    return deletedElement;
}
  • 功能：删除指定位置的节点并返回被删除的节点的值。
  • 参数：
    • CircularLinkedList *list，指向链表结构。
    • size_t index，删除位置的索引。
  • 操作：
    • 检查删除位置是否合法，如果不合法则返回 -1。
    • 如果删除位置是头节点：
      • 保存头节点。
      • 如果链表只有一个节点，将 head 指针置为 NULL。
      • 如果链表有多个节点，找到尾节点，更新头节点指针，并将尾节点的 next 指针指向新的头节点。
      • 释放被删除的头节点，返回其数据。
    • 如果删除位置不是头节点，找到删除位置的前一个节点，保存要删除的节点，更新前一个节点的 next 指针指向要删除节点的后继节点，释放要删除的节点，返回其数据。
    • 更新链表的节点个数。

获取指定位置的元素

// 获取指定位置的元素
int getElementAt(const CircularLinkedList *list, size_t index) {
    if (index >= list->size) {
        return -1; // 返回无效的索引
    }

    Node *currentNode = list->head;
    for (size_t i = 0; i < index; i++) {
        currentNode = currentNode->next;
    }

    return currentNode->data; // 返回指定位置的元素
}
  • 功能：获取指定位置的节点值。
  • 参数：
    • const CircularLinkedList *list，指向链表结构。
    • size_t index，目标位置的索引。
  • 操作：
    • 检查索引是否合法，如果不合法则返回 -1。
    • 从头节点开始遍历，直到找到目标位置的节点。
    • 返回目标位置节点的值。

修改指定位置的元素

// 修改指定位置的元素
void modifyAt(CircularLinkedList *list, size_t index, int newValue) {
    if (index >= list->size) {
        return; // 忽略无效的修改位置
    }

    Node *currentNode = list->head;
    for (size_t i = 0; i < index; i++) {
        currentNode = currentNode->next;
    }

    currentNode->data = newValue; // 修改节点的值
}
  • 功能：修改指定位置的节点值。
  • 参数：
    • CircularLinkedList *list，指向链表结构。
    • size_t index，目标位置的索引。
    • int newValue，新值。
  • 操作：
    • 检查索引是否合法，如果不合法则直接返回。
    • 从头节点开始遍历，直到找到目标位置的节点。
    • 修改目标位置节点的值。

释放单向循环链表的内存

// 释放单向循环链表内存
void destroyCircularLinkedList(CircularLinkedList *list) {
    if (list->head == NULL) {
        return;
    }
    Node *currentNode = list->head;
    Node *nextNode;
    do {
        nextNode = currentNode->next;
        free(currentNode);
        currentNode = nextNode;
    } while (currentNode != list->head);

    list->head = NULL;
    list->size = 0;
}
  • 功能：释放单向循环链表中所有节点的内存。
  • 参数：CircularLinkedList *list，指向需要释放的链表结构。
  • 操作：
    • 如果链表为空，直接返回。
    • 从头节点开始遍历，每次保存当前节点的下一个节点的指针，释放当前节点的内存。
    • 继续遍历，直到回到头节点。
    • 将链表的头节点指针 head 置为 NULL，将链表的节点个数 size 置为 0。

打印所有元素

// 打印单向循环链表中的所有元素
void printCircularLinkedList(const CircularLinkedList *list) {
    if (list->head == NULL) {
        printf("链表为空\n");
        return;
    }
    Node *currentNode = list->head;
    do {
        printf("%d ", currentNode->data);
        currentNode = currentNode->next;
    } while (currentNode != list->head);
    printf("\n");
}
  • 功能：打印单向循环链表中的所有节点值。
  • 参数：const CircularLinkedList *list，指向需要打印的链表结构。
  • 操作：
    • 如果链表为空，打印“链表为空”并返回。
    • 从头节点开始遍历，每次打印当前节点的值。
    • 继续遍历，直到回到头节点。

5. 代码示例

下面是一个完整的双向循环链表实现的代码，包括初始化、插入、删除、获取和修改元素，以及释放链表的内存的所有基本操作。

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

// 双向循环链表节点结构定义
typedef struct DNode {
    int data;             // 节点存储的数据
    struct DNode *prev;   // 指向前一个节点的指针
    struct DNode *next;   // 指向后一个节点的指针
} DNode;

// 双向循环链表结构定义
typedef struct {
    DNode *head; // 双向循环链表头节点指针
    size_t size; // 双向循环链表中的节点个数
} DoublyCircularLinkedList;

// 初始化双向循环链表
void initDoublyCircularLinkedList(DoublyCircularLinkedList *list) {
    list->head = NULL; // 初始化头节点为空
    list->size = 0;    // 初始化节点个数为0
}

// 在指定位置插入元素
void insertAt(DoublyCircularLinkedList *list, size_t index, int element) {
    if (index > list->size) {
        return; // 忽略无效的插入位置
    }

    DNode *newNode = (DNode *)malloc(sizeof(DNode)); // 创建新节点
    newNode->data = element;
    newNode->prev = NULL;
    newNode->next = NULL;

    if (index == 0) { // 插入位置是头节点
        if (list->head == NULL) { // 如果链表为空
            newNode->next = newNode;
            newNode->prev = newNode;
            list->head = newNode;
        } else {
            DNode *tail = list->head->prev;
            newNode->next = list->head;
            newNode->prev = tail;
            list->head->prev = newNode;
            tail->next = newNode;
            list->head = newNode;
        }
    } else {
        DNode *current = list->head;
        for (size_t i = 0; i < index - 1; i++) {
            current = current->next;
        }
        newNode->next = current->next;
        newNode->prev = current;
        if (current->next != NULL) {
            current->next->prev = newNode;
        }
        current->next = newNode;
    }

    list->size++; // 更新节点个数
}

// 删除指定位置的元素并返回被删除的元素
int deleteAt(DoublyCircularLinkedList *list, size_t index) {
    if (index >= list->size) {
        return -1; // 忽略无效的删除位置
    }

    int deletedElement;

    if (index == 0) { // 删除位置是头节点
        DNode *temp = list->head;
        if (list->head->next == list->head) { // 如果链表只有一个节点
            list->head = NULL;
        } else {
            DNode *tail = list->head->prev;
            list->head = temp->next;
            list->head->prev = tail;
            tail->next = list->head;
        }
        deletedElement = temp->data;
        free(temp); // 释放被删除节点的内存
    } else {
        DNode *current = list->head;
        for (size_t i = 0; i < index - 1; i++) {
            current = current->next;
        }
        DNode *temp = current->next;
        current->next = temp->next;
        if (temp->next != NULL) {
            temp->next->prev = current;
        }
        deletedElement = temp->data;
        free(temp); // 释放被删除节点的内存
    }

    list->size--; // 更新节点个数
    return deletedElement;
}

// 获取指定位置的元素
int getElementAt(const DoublyCircularLinkedList *list, size_t index) {
    if (index >= list->size) {
        return -1; // 返回无效的索引
    }

    DNode *currentNode = list->head;
    for (size_t i = 0; i < index; i++) {
        currentNode = currentNode->next;
    }

    return currentNode->data; // 返回指定位置的元素
}

// 修改指定位置的元素
void modifyAt(DoublyCircularLinkedList *list, size_t index, int newValue) {
    if (index >= list->size) {
        return; // 忽略无效的修改位置
    }

    DNode *currentNode = list->head;
    for (size_t i = 0; i < index; i++) {
        currentNode = currentNode->next;
    }

    currentNode->data = newValue; // 修改节点的值
}

// 释放双向循环链表内存
void destroyDoublyCircularLinkedList(DoublyCircularLinkedList *list) {
    if (list->head == NULL) {
        return;
    }
    DNode *currentNode = list->head;
    DNode *nextNode;
    do {
        nextNode = currentNode->next;
        free(currentNode);
        currentNode = nextNode;
    } while (currentNode != list->head);

    list->head = NULL;
    list->size = 0;
}

// 打印双向循环链表中的所有元素
void printDoublyCircularLinkedList(const DoublyCircularLinkedList *list) {
    if (list->head == NULL) {
        printf("链表为空\n");
        return;
    }
    DNode *currentNode = list->head;
    do {
        printf("%d ", currentNode->data);
        currentNode = currentNode->next;
    } while (currentNode != list->head);
    printf("\n");
}

// 主函数测试双向循环链表操作
int main() {
    DoublyCircularLinkedList myList; // 声明双向循环链表

    initDoublyCircularLinkedList(&myList); // 初始化双向循环链表
    printf("初始化双向循环链表成功!\n");

    insertAt(&myList, 0, 1); // 在索引0处插入元素1
    insertAt(&myList, 1, 2); // 在索引1处插入元素2
    insertAt(&myList, 2, 3); // 在索引2处插入元素3
    printf("向双向循环链表插入了3个元素\n");
    printDoublyCircularLinkedList(&myList); // 打印链表中的元素

    printf("双向循环链表长度为: %zu\n", myList.size); // 获取双向循环链表长度

    insertAt(&myList, 1, 4); // 在索引1处插入元素4
    printf("在索引1处插入元素4\n");
    printDoublyCircularLinkedList(&myList); // 打印链表中的元素

    printf("双向循环链表长度为: %zu\n", myList.size); // 再次获取双向循环链表长度

    printf("删除索引1处的元素,该元素值是: %d\n", deleteAt(&myList, 1)); // 删除索引1处的元素
    printDoublyCircularLinkedList(&myList); // 打印链表中的元素

    destroyDoublyCircularLinkedList(&myList); // 销毁双向循环链表
    printf("双向循环链表销毁成功!\n");

    return 0;
}

 

TENET-
关注
专栏目录
python实现数据结构中双向循环链表操作的示例
12-16
双向循环链表是一种重要的数据结构，它允许我们在链表的两端进行插入和删除操作，同时每个节点都包含指向其前一个和后一个节点的引用，形成一个闭合的循环。在给定的示例中，我们看到了如何用Python实现这种数据结构...
C语言数据结构之双向循环链表的实例
08-30
C语言数据结构之双向循环链表的实例 在计算机科学中，链表是一种常用的数据结构，它可以动态地分配内存来存储数据，且可以随机访问和插入、删除数据。双向循环链表是一种特殊的链表，它可以同时在链表的头部和尾部...
带表 双向循环链表的简单操作
Allureyou的博客
12-23 454
#include struct node { int num; struct node *prior; struct node *next; }; typedef struct node Node; typedef Node * DLink; void create_d_link(DLink *head) { *head = (DLink)malloc(
双向链表的相关操作
weixin_45796808的博客
09-03 137
双向链表的相关操作 #include<stdio.h> #include<stdlib.h> #include<time.h> typedef struct LinkListNode { int data; struct LinkListNode* prior; struct LinkListNode* next; }node,*LinkList; //结构体变量类型 void GreatLinklistTail(LinkList* head); // 建立链
双向循环链表的操作
Shijia Yin
05-26 224
一、双向循环链表的实现，如果理解了前面的双向链表和循环链表，那么理解双向循环链表是一件很简单的事情，这里的实现是在我之前的双向链表的基础上，将尾结点的next指向头结点，将头结点的pioneer指向尾结点，就可以实现双向循环链表了。 typedef struct DNode { int data; struct DNode *front; struct DNode *nex...
双向循环链表操作
weixin_30491641的博客
02-20 122
双链表： 1 2 3 4 5 6 7 8 9 10 11 12 1 3 5 7 9 11 12 10 8 6 4 2 1。设计节点 typedef int datatyped typeddef struct node { typedata data; struct node * next; struct node *prev; }listnode ,*linklist;...
C语言演示链表操作.rar_C语言_双向循环链表_数据结构_链表 list_链表操作
09-19
学习和掌握链表操作，尤其是双向循环链表，对于理解和编写复杂的数据结构和算法至关重要，这对于软件开发人员来说是必不可少的技能。在实际应用中，链表常用于实现如队列、栈、哈希表等高级数据结构，以及解决各种...
双向循环链表基本操作
浮生之居士
12-22 637
双向循环链表网上弄来的代码，可以说很优秀了。#include <stdio.h> #include <stdlib.h> #include <malloc.h> #include <ctype.h> #define LIST_ELEM_TYPE int /*链表元素数据类型*/ LIST_ELEM_TYPE largest=1 ; /*链表节点类型*/ typedef struct
双向循环链表的基本操作
你看看这个C还有++
05-05 402
实现链表的增删查,清空,销毁 #pragma once typedef int DataType; //链表的节点结构 typedef struct DLinkList { struct DLinkList* next; struct DLinkList* prior; DataType data; }DLinkList,*DLNode; // 链表的初始化 void DL...
双向循环链表操作的实现
代码改变世界，keep coding。
12-20 1711
1、 建立一个空表。 2、 插入第i个结点。 3、 删除第i个结点。 4、 插入第1个结点。 5、 插入最后一个结点。 6、 就地逆置 public class TwoWayLinkedListNode { AnyType data; TwoWayLinkedListNode pre; TwoWayLinkedListNode next; public TwoWayLi
【数据结构-C】双向循环链表基本操作及图解分析
qq_52763385的博客
02-04 4562
目录 ????双向链表介绍 ????双向链表的基本操作及图解分析 ????1.双向链表创建新的结点 ????2.双向链表初始化 ????3.双向链表的尾插 ????4.双向链表的头插 ????5.双向链表的头删 ????6.双向链表的尾删 ????7.查找某个结点并返回该节点地址 ????8.在某结点前插入一个新的结点 ????9.删除某个结点 ????10.销毁双向链表 总结 ????双向链表介绍 双向链表的结点：指针域1+数据域+指针域2 ????指针域1：指向该结点
双向循环链表(图文讲解)
deroy
02-25 2628
文章目录双向循环链表结构体初始化函数添加数据头插删除数据显示函数示例程序一(简易版本)：运行结果：示例程序二 双向循环链表 结构体 typedef struct node { int data; struct node* pre; //指向前驱 struct node* next; //指向后继 }NODE; 双链表是链表的一种，由节点组成，每个数据结点中都有两个指针，分别指向直接后继和直接前驱。 初始化函数 NODE * Init() { NODE* head = (NODE*)mall
双向循环链表的讲解及实现（图解+代码/C语言）
最新发布
qq_62306969的博客
01-04 4863
本文主要分享了双向循环链表（带头）的写法，使用C语言完成，文中附有具体的结构图片帮助大家理解，希望对大家有帮助
【C语言数据结构】双向循环链表
W1024201的博客
03-08 6894
目录 前言 一、双向循环链表 循环结构 1.双向循环链表头文件及函数声明 2.初始化 1.结点构造 2.初始化函数 3.结点申请 4.数据插入 1.按位置插入 2.尾插 3.头插 5.查找 6.数据删除 1.按位置删除 2.按值删除 3.尾删 4.头删 7.清空与销毁 1.清空 2.销毁 8.双向循环链表源文件及整体函数实现 总结 前言 这次我们将学习双向循环链表，首先了解双向链表和循环链表的定义和讲解。 双向链表也叫双链...
数据结构：双向循环链表的操作与实现
在双向循环链表中，每个节点不仅包含数据，还有指向前后节点的指针，形成一个闭合的环状结构。 双向循环链表的构造通常涉及创建表头节点，如在描述中所示的`DblList`模板类的构造函数中，它创建了一个包含指定值`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

TENET-

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值