在数据结构中如何使用(双)链表？

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

文章目录

1. 定义

2. 双链表和单链表的区别

3. 代码示例

3.1 双链表节点和结构定义

3.2 初始化双链表

3.3 返回双链表的长度

3.4 在指定位置插入元素

3.5 在末尾插入元素

3.6 删除指定位置的元素并返回被删除的元素

3.7 删除末尾元素

3.8 获取指定位置的元素

3.9 修改指定位置的元素

3.10 释放双链表内存

4. 流程

5. 完整代码

1. 定义

双链表（Doubly Linked List）是一种链表数据结构，其中每个节点不仅包含一个数据域，还包含两个指针域，一个指向前驱节点，一个指向后继节点。相比单链表，双链表可以更方便地进行双向遍历，插入和删除操作也更高效。

双链表的定义和操作

  1. 节点的定义：每个节点包含数据部分和指向前一个节点和后一个节点的指针部分。
  2. 头节点和尾节点：链表的头节点是链表的起点，尾节点是链表的终点，通过头节点可以遍历整个链表。
  3. 双向链接：每个节点都有指向前一个节点和后一个节点的指针，因此可以双向遍历链表。
  4. 动态扩展：节点在内存中不必是连续的，可以动态分配和释放内存。

2. 双链表和单链表的区别

结构上的区别

  • 单链表：

    • 每个节点包含一个数据域和一个指向下一个节点的指针。
    • 只有从头节点向下遍历的方向，没有指向前一个节点的指针。
    • 头节点没有前驱节点，尾节点的指针指向 NULL。

  • 双链表：

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

单链表的优缺点

优点：

  1. 简单性：实现和维护相对简单，节点只需要存储一个指针，内存开销小。
  2. 内存占用较少：每个节点只包含一个指针，因此内存占用较双链表少。
  3. 插入和删除操作效率较高：在已知前驱节点的情况下，插入和删除节点的时间复杂度为 O(1)。

缺点：

  1. 查找效率较低：从头节点遍历到目标节点的时间复杂度为 O(n)。
  2. 只能单向遍历：不能从尾节点向前遍历到头节点，灵活性差。

双链表的优缺点

优点：

  1. 双向遍历：可以从任一节点双向遍历，即可以向前遍历到头节点，也可以向后遍历到尾节点。
  2. 删除节点更方便：在已知节点本身的情况下，删除节点时不需要知道其前驱节点，因为可以通过节点本身直接访问其前驱节点和后继节点。
  3. 灵活性高：在某些情况下，双向遍历能够更方便地实现算法，比如在某些需要回溯的场景下。

缺点：

  1. 内存占用较大：每个节点包含两个指针，内存占用较单链表多。
  2. 实现和维护相对复杂：双向链表的实现和维护比单链表更复杂，需要处理更多的指针操作。
  3. 插入和删除操作相对复杂：插入和删除操作需要同时更新前驱和后继节点的指针，操作较为繁琐。

3. 代码示例

3.1 双链表节点和结构定义

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

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

// 双链表结构定义
typedef struct {
    DNode *head;  // 双链表头节点指针
    DNode *tail;  // 双链表尾节点指针
    size_t size;  // 双链表中的节点个数
} DoublyLinkedList;
  • DNode 结构体定义了双链表的节点，包含数据域 data 和指向前一个节点的指针 prev 以及指向后一个节点的指针 next。
  • DoublyLinkedList 结构体定义了双链表，包含指向头节点的指针 head 和指向尾节点的指针 tail，以及链表中节点的个数 size。

3.2 初始化双链表

// 初始化双链表
void initDoublyLinkedList(DoublyLinkedList *list) {
    list->head = NULL; // 初始化头节点为空
    list->tail = NULL; // 初始化尾节点为空
    list->size = 0;    // 初始化节点个数为0
}

  • initDoublyLinkedList 函数将双链表的头节点和尾节点设置为 NULL，并将节点个数初始化为 0。

3.3 返回双链表的长度

// 返回双链表的长度
size_t getLength(const DoublyLinkedList *list) {
    return list->size; // 返回双链表的节点个数
}
  •  getLength 函数返回双链表中的节点个数。

3.4 在指定位置插入元素

// 在指定位置插入元素
void insertAt(DoublyLinkedList *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) {
        newNode->next = list->head;
        if (list->head != NULL) {
            list->head->prev = newNode;
        }
        list->head = newNode; // 新节点成为头节点
        if (list->tail == NULL) {
            list->tail = newNode; // 如果链表为空，新节点也是尾节点
        }
    } else if (index == list->size) {
        // 如果插入位置是尾节点
        newNode->prev = list->tail;
        if (list->tail != NULL) {
            list->tail->next = newNode;
        }
        list->tail = newNode; // 新节点成为尾节点
        if (list->head == NULL) {
            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++; // 更新节点个数
}
  • insertAt 函数在双链表的指定位置插入一个新的元素。如果插入位置是 0，则新节点成为头节点。如果插入位置是链表的末尾，则新节点成为尾节点。否则，通过遍历找到插入位置的前一个节点，并在该位置插入新节点。更新链表的节点个数。

3.5 在末尾插入元素

// 在末尾插入元素
void insertEnd(DoublyLinkedList *list, int element) {
    insertAt(list, list->size, element); // 在链表末尾插入元素
}
  • insertEnd 函数在双链表末尾插入一个新的元素，通过调用 insertAt 函数实现。

3.6 删除指定位置的元素并返回被删除的元素

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

    int deletedElement;

    // 如果删除位置是头节点
    if (index == 0) {
        DNode *temp = list->head;
        list->head = temp->next;
        if (list->head != NULL) {
            list->head->prev = NULL;
        } else {
            list->tail = NULL; // 如果链表只有一个节点
        }
        deletedElement = temp->data;
        free(temp); // 释放被删除节点的内存
    } else if (index == list->size - 1) {
        // 如果删除位置是尾节点
        DNode *temp = list->tail;
        list->tail = temp->prev;
        if (list->tail != NULL) {
            list->tail->next = NULL;
        } else {
            list->head = NULL; // 如果链表只有一个节点
        }
        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;
}
  • deleteAt 函数删除双链表中指定位置的节点，并返回该节点的值。如果删除位置是 0，则直接删除头节点。如果删除位置是链表的末尾，则删除尾节点。否则，通过遍历找到删除位置的前一个节点，并删除该位置的节点。更新链表的节点个数。

3.7 删除末尾元素

// 删除末尾元素并返回被删除的元素
int deleteEnd(DoublyLinkedList *list) {
    return deleteAt(list, list->size - 1); // 删除链表末尾的元素
}
  • deleteEnd 函数删除双链表末尾的节点，通过调用 deleteAt 函数实现。

3.8 获取指定位置的元素

// 获取指定位置的元素
int getElementAt(const DoublyLinkedList *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; // 返回指定位置的元素
}
  • getElementAt 函数返回双链表中指定位置的元素。通过遍历找到指定位置的节点，并返回该节点的值。

3.9 修改指定位置的元素

// 修改指定位置的元素
void modifyAt(DoublyLinkedList *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; // 修改节点的值
}
  • modifyAt 函数修改双链表中指定位置的元素值。通过遍历找到指定位置的节点，并修改该节点的值。

3.10 释放双链表内存

// 释放双链表内存
void destroyDoublyLinkedList(DoublyLinkedList *list) {
    // 遍历释放每个节点的内存
    DNode *currentNode = list->head;
    while (currentNode != NULL) {
        DNode *temp = currentNode;
        currentNode = currentNode->next;
        free(temp); // 释放每个节点的内存
    }

    list->head = NULL; // 头节点置为空
    list->tail = NULL; // 尾节点置为空
    list->size = 0;    // 节点个数置为0
}
  • destroyDoublyLinkedList 函数释放双链表使用的内存。通过遍历链表，逐个释放每个节点的内存。将头节点和尾节点指针置为空，节点个数置为 0。

4. 流程

初始化双链表：

  • 判断链表是否为空。
  • 如果为空，设置头指针和尾指针为NULL。
  • 如果不为空，创建头节点和尾节点。

插入节点：

  • 判断插入位置是在头部、尾部还是中间。
  • 如果是头部，设置新节点为头节点并更新头节点的前驱指针。
  • 如果是尾部，设置新节点为尾节点并更新尾节点的后继指针。
  • 如果是在中间，找到插入位置前一个节点，设置新节点的前驱和后继指针，并更新前一个节点和后一个节点的指针。
  • 更新链表长度。

删除节点：

  • 判断删除位置是在头部、尾部还是中间。
  • 如果是头部，找到头节点并更新头节点指针。
  • 如果是尾部，找到尾节点并更新尾节点指针。
  • 如果是在中间，找到要删除节点的前一个节点，更新前一个节点和后一个节点的指针。
  • 释放被删除节点的内存。
  • 更新链表长度。

遍历链表：

  • 从头节点开始。
  • 判断当前节点是否为NULL。
  • 如果不为NULL，访问节点数据并移动到下一个节点，重复判断。
  • 如果为NULL，遍历结束。

修改节点数据：

  • 找到目标节点。
  • 更新节点数据。

 

5. 完整代码

代码包括双链表的基本操作，包括初始化、插入、删除、获取和修改元素，以及释放链表的内存.

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

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

// 双链表结构定义
typedef struct {
    DNode *head; // 双链表头节点指针
    DNode *tail; // 双链表尾节点指针
    size_t size; // 双链表中的节点个数
} DoublyLinkedList;

// 初始化双链表
void initDoublyLinkedList(DoublyLinkedList *list) {
    list->head = NULL; // 初始化头节点为空
    list->tail = NULL; // 初始化尾节点为空
    list->size = 0;    // 初始化节点个数为0
}

// 返回双链表的长度
size_t getLength(const DoublyLinkedList *list) {
    return list->size; // 返回双链表的节点个数
}

// 在指定位置插入元素
void insertAt(DoublyLinkedList *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) { // 插入位置是头节点
        newNode->next = list->head;
        if (list->head != NULL) {
            list->head->prev = newNode;
        }
        list->head = newNode;
        if (list->tail == NULL) {
            list->tail = newNode;
        }
    } else if (index == list->size) { // 插入位置是尾节点
        newNode->prev = list->tail;
        if (list->tail != NULL) {
            list->tail->next = newNode;
        }
        list->tail = newNode;
        if (list->head == NULL) {
            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++; // 更新节点个数
}

// 在末尾插入元素
void insertEnd(DoublyLinkedList *list, int element) {
    insertAt(list, list->size, element); // 在链表末尾插入元素
}

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

    int deletedElement;

    if (index == 0) { // 删除位置是头节点
        DNode *temp = list->head;
        list->head = temp->next;
        if (list->head != NULL) {
            list->head->prev = NULL;
        } else {
            list->tail = NULL; // 如果链表只有一个节点
        }
        deletedElement = temp->data;
        free(temp); // 释放被删除节点的内存
    } else if (index == list->size - 1) { // 删除位置是尾节点
        DNode *temp = list->tail;
        list->tail = temp->prev;
        if (list->tail != NULL) {
            list->tail->next = NULL;
        } else {
            list->head = NULL; // 如果链表只有一个节点
        }
        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 deleteEnd(DoublyLinkedList *list) {
    return deleteAt(list, list->size - 1); // 删除链表末尾的元素
}

// 获取指定位置的元素
int getElementAt(const DoublyLinkedList *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(DoublyLinkedList *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 destroyDoublyLinkedList(DoublyLinkedList *list) {
    DNode *currentNode = list->head;
    while (currentNode != NULL) {
        DNode *temp = currentNode;
        currentNode = currentNode->next;
        free(temp); // 释放每个节点的内存
    }

    list->head = NULL; // 头节点置为空
    list->tail = NULL; // 尾节点置为空
    list->size = 0;    // 节点个数置为0
}

// 打印双链表中的所有元素
void printDoublyLinkedList(const DoublyLinkedList *list) {
    DNode *currentNode = list->head;
    while (currentNode != NULL) {
        printf("%d ", currentNode->data);
        currentNode = currentNode->next;
    }
    printf("\n");
}

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

    initDoublyLinkedList(&myList); // 初始化双链表
    printf("初始化双链表成功!\n");

    insertEnd(&myList, 1); // 链表尾部插入元素1
    insertEnd(&myList, 2); // 链表尾部插入元素2
    insertEnd(&myList, 3); // 链表尾部插入元素3
    printf("向双链表插入了3个元素\n");
    printDoublyLinkedList(&myList); // 打印链表中的元素

    printf("双链表长度为: %zu\n", getLength(&myList)); // 获取双链表长度

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

    printf("双链表长度为: %zu\n", getLength(&myList)); // 再次获取双链表长度

    printf("索引1处的元素为: %d\n", getElementAt(&myList, 1)); // 获取索引1处的元素

    modifyAt(&myList, 0, 5); // 修改索引0处的元素
    printf("把索引0处的元素修改为5\n");
    printDoublyLinkedList(&myList); // 打印链表中的元素

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

    destroyDoublyLinkedList(&myList); // 销毁双链表
    printf("双链表销毁成功!\n");

    return 0;
}
  • 初始化双链表：initDoublyLinkedList 函数初始化双链表，将头节点和尾节点设置为 NULL，节点个数初始化为 0。
  • 返回双链表的长度：getLength 函数返回双链表中的节点个数。
  • 在指定位置插入元素：insertAt 函数在双链表的指定位置插入一个新节点，根据插入位置调整前后节点的指针。
  • 在末尾插入元素：insertEnd 函数在双链表末尾插入一个新节点，调用 insertAt 函数实现。
  • 删除指定位置的元素：deleteAt 函数删除双链表中指定位置的节点，并返回该节点的值，根据删除位置调整前后节点的指针。
  • 删除末尾元素：deleteEnd 函数删除双链表末尾的节点，调用 deleteAt 函数实现。
  • 获取指定位置的元素：getElementAt 函数返回双链表中指定位置的元素，通过遍历找到目标节点。
  • 修改指定位置的元素：modifyAt 函数修改双链表中指定位置的节点的值，通过遍历找到目标节点并更新其数据。
  • 释放双链表内存：destroyDoublyLinkedList 函数释放双链表中的所有节点内存，并将链表恢复到初始状态。
  • 打印双链表中的所有元素：printDoublyLinkedList 函数遍历双链表并打印每个节点的数据。

TENET-
关注
  • 20
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构-链表结构-双向链表
qq_44715376的博客
08-01 3689
双向链表
数据结构——双链表
zhongshun0928的博客
04-15 158
创建文件DLinkList.cpp，里面存入双链表的基本方法。 //双链表 #include <stdlib.h> #include <stdio.h> #define ElemType int typedef struct DNode{ ElemType data; struct DNode *prior,*next; }DNode,*DLinkList; //初始化双链表（带头结点） bool InitDLinkList(DLinkList &L){
数据结构——双向链表
麦麦的博客
03-11 2234
数据结构——双向链表：本文对双向链表的功能实现进行了详细地讲解，并与单链表的实现进行对比，干货满满，图文并茂，过万好文，不容错过！！！
Java数据结构与算法——双向链表
★★光亭★★
03-11 6137
Java数据结构与算法——双向链表
数据结构—双链表
qq_55627064的博客
12-25 810
简介： 双向链表是一种复杂类型的链表，它的节点包含指向前一个节点和下一个节点的指针。 因此，在双向链表中，节点由三部分组成：节点数据，指向下一个节点的指针(next指针)，指向前一个节点的指针(prev指针)。 图示： 与单链表相比： 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。 单向链表不能自我删除，需要靠辅助节点 ，而双向 链表，则可以自我删除，所以前面我们单链表删除时节点，总是找到temp,temp是待删除节点的前一个节点(认真体会). 相比单链表增加了指向前一个节点的指针
数据结构的双链表算法
09-27
双链表是数据结构中的一种重要类型，它在计算机科学中有着广泛的应用。与单链表相比，双链表的特点在于每个节点不仅包含指向下一个节点的指针，还包含一个指向前一个节点的指针，这使得双向操作更加便捷。 在双链表...
C语言 数据结构双向链表简单实例
08-31
双向链表是一种数据结构，它可以在链表的任意位置插入或删除元素。在本实例中，我们将实现双向链表的基本操作，包括建立链表、遍历链表、删除元素、插入元素等。 1. 建立链表： 我们可以使用尾插法建立一个双向...
链表-使用PHP实现的双向链表数据结构.zip
03-13
在本案例中，"链表-使用PHP实现的双向链表数据结构.zip" 是一个压缩文件，其中包含了一个使用PHP语言实现的双向链表数据结构的示例。双向链表是链表的一种变体，与单向链表不同，它允许从两个方向遍历链表。每个节点...
Python数据结构之双向链表的定义与使用方法示例
09-20
Python中的双向链表是一种线性数据结构，与单链表相比，它在每个节点中不仅包含指向下一个节点的指针，还包含一个指向前一个节点的指针。这使得双向链表可以在正向和反向两个方向上进行遍历，提高了操作的灵活性。 ...
【数据结构】——1.1树
qq_43507078的博客
09-07 1035
树，二叉树
数据结构-栈、队列-相关练习
2401_86587256的博客
09-05 1463
数据结构初阶部分，栈和队列的相关练习。
数据结构 Java DS——分享部分链表题目 (2)
最新发布
cjejwe的博客
09-10 692
关于JAVA的链表,笔者已经写了两篇博客来介绍了,今天给笔者们带来第三篇,也是分享了一些笔者写过的,觉得挺好的题目,链接也已经挂上了,笔者们可以去看看。
栈—数据结构
weixin_63722559的博客
09-06 1085
6、获取栈顶元素（获取栈顶元素，在外面开一个空间，将该空间的地址传过去，进行获取元素，以便于区分元素还是返回值）入栈的方向是是增栈的方式，放入数据的是满栈的方式。入栈的方向是是减栈的方式，放入数据的是满栈的方式。入栈的方向是是增栈的方式，放入数据的是空栈的方式。入栈的方向是是减栈的方式，放入数据的是空栈的方式。3、出栈（看一下，出去的元素，所以和6一样）1、入栈：先放入输入，再移动栈顶指针。2、出栈：先移动栈顶指针，再数据弹出。1、入栈：先挪栈顶指针，再放入数据。2、出栈：先移出数据，再移动指针。
【数据结构和算法实践-树-LeetCode101-对称二叉树】
Mao_c的博客
09-06 393
leetcode题目，求一个对称的树结构
Java-数据结构-栈和队列-Stack和Queue (oﾟ▽ﾟ)o
2303_80388948的博客
09-07 890
栈：是一种特殊的线性表，其 只允需在固定的一端进行插入和删除操作。 进行插入和删除的一端叫做栈顶，另一端叫做栈底。并且要遵循 先进后出 的规则。 队列：是一种只允许一端进行插入元素，在另一端进行删除元素的特殊的线性表。 队列具有 先进先出 的性质：进行插入的一端叫做队尾，进行删除的一端叫做队头。也就是队尾进，队头出。
数据结构——单链表实现和注释浅解
hedhjd的博客
09-07 377
【代码】数据结构——单链表实现和注释浅解。
常见的排序
2302_79712403的博客
09-07 855
常见的10大排序，这里先详细的介绍前7种排序；稳定性定义：如果两个元素具有相同的关键字，那么在排序后他们的相对顺序不变；排序前有标记的5在前面，排序后依旧在前面即稳定，如果位置互换了就不稳定；
【数据结构】基本概念和术语
Sakura_ding的博客
09-09 892
是指一个数学模型以及定义在该模型上的一组操作。抽象数据类型的定义仅取决于它的一组逻辑特性，而与其在计算机内部如何表示和实现无关，即不论其内部结构如何变化，只要它的数学特性不变，都不影响其外部的使用。抽象数据类型和数据类型实质上是一个概念。“抽象”的意义在于数据类型的数学抽象特性。抽象数据类型的定义由一个值域和定义在该值域上的一组操作组成。若按其值的不同特性，可细分为下列三种类型：原子类型 (atomic data type)属原子类型的变量的值是不可分解的。
数据结构07
m0_52024881的博客
09-04 432
条件1.vector或者List的长度小于当前的lever值的时候才将结点的值入vector或者List，这就保证了始终保留的是最右结点。不妨对照题干上的例子对照进行单步脑海运行一下。其中C++和java语言中都有一个重要的if筛选条件，还有一个条件是2.先遍历右孩子再遍历左孩子；
数据结构讲解：循环链表与双向链表操作
在数据结构与算法的学习中，循环链表和双向链表是两种重要的链式存储结构，它们扩展了单链表的功能，为数据操作提供了更多的便利。 5.1 带头结点的链表 带头结点的链表是在线性链表的第一个元素前增加一个特殊的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

TENET-

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

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

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

打赏作者

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

抵扣说明：

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

余额充值