五、数据结构——双向不循环链表的基本操作详解：创建、插入（头插法、尾插法、任意点插法）、删除（头删法、尾删法、任意位置删法）、查询（按值查下标、按下标查值）、遍历链表和清空链表

已于 2023-06-16 01:42:32 修改
阅读量522 收藏 3
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构 c语言 linux 算法
于 2023-06-16 01:25:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57737603/article/details/131212550
版权

详细介绍C语言中双向不循环链表的实现和基本操作

目录

1、双向不循环链表的定义和结构
2、判断链表是否为空
3、创建双向不循环链表
4、在双向不循环链表中插入节点
5、从双向不循环链表中删除节点
6、查找链表的元素或元素的下标
7、修改链表的元素
8、获取链表的长度
9、遍历双向不循环链表
10、释放双向不循环链表的内存
11、完整代码

1、双向不循环链表的定义和结构：

我们将解释双向不循环链表的概念，并说明每个节点的结构。每个节点包含一个数据元素，一个指向前一个节点的指针（prev），以及一个指向下一个节点的指针（next）。

// 链表节点结构体
typedef struct Node {
    typData data;// 节点数据
    int tail;//记录节点数
    struct Node *prev;//指向上一个节点的指针
    struct Node *next;//指向下一个节点的指针
} Linklist, *Plinklist;

2、判断链表是否为空

// 判断链表是否为空
int isEmpty(Plinklist list){
    if(list == NULL || list->tail == 0){
        //puts("表是空的！");
        return 1;//真空
    }else{
        return 0;//非空
    }
}

3、创建双向不循环链表：

我们将介绍如何创建一个空的双向不循环链表，并确保头节点的正确设置。
初始化（创建）：表头不存放数据

// 创建链表
Plinklist createLinkedList(Plinklist *list){
    (*list) = (Plinklist)malloc(sizeof(Linklist));//为表头申请空间
    if(list == NULL){
        perror("createLinkedList list malloc");
    }
    (*list)->tail = 0;//记录节点数
    (*list)->prev = NULL;//头节点的上一个节点置空
    (*list)->next = NULL;//头节点的下一个节点置空
    return *list;
}

4、在双向不循环链表中插入节点：

我们将讨论在链表的头部、尾部和任意插入节点的方法。这包括更新指针和调整节点的链接。
头插法：
在这里插入图片描述

// 在链表头部插入元素
void insertAtHead(Plinklist list, typData value){
    if(list == NULL){
        puts("insert head arg err");
        return ;
    }

    Plinklist newNode = (Plinklist)malloc(sizeof(Linklist));
    if(newNode == NULL){
        perror("insert head newNode malloc");//头插入内存分配失败
        return ;
    }

    newNode->data = value;//设置新节点的数据值
    newNode->prev = list;//新节点的prev指针指向头节点
    newNode->next = list->next;//新节点的next指针的作用是替代头节点的next指针指向NULL
    if(list->next != NULL){
        list->next->prev = newNode;更新头节点的前驱节点为新节点
    }
    list->next = newNode;//更新头节点的后继节点为新节点
    list->tail++;//链表长度加一
}

尾插法：
在这里插入图片描述

// 在链表尾部插入元素
void insertAtTail(Plinklist list, typData value){
    if(list == NULL){
        puts("insert tail arg err");
        return ;
    }

    Plinklist newNode = (Plinklist)malloc(sizeof(Linklist));
    if(newNode == NULL){
        perror("insert tail newNode malloc");
        return ;
    }
    newNode->data = value;// 设置新节点的数据值
    newNode->next = NULL;// 新节点的后继节点指向NULL

    Plinklist current_tail = list;// 重新定义一个新指针指向头节点
    while(current_tail->next != NULL){
        current_tail = current_tail->next;// 遍历找到链表的尾节点
    }

    newNode->prev = current_tail;// 新节点的前驱节点指向尾节点
    current_tail->next = newNode;// 尾节点的后继节点指向新节点

    list->tail++;// 节点数加一

}

指定下标插入法
在这里插入图片描述

// 在指定位置插入元素
void insertAtPosition(Plinklist list, int position, typData value){
    if(list ==NULL){
        puts("insert position arg err");
        return ;
    }

    if(position < 0 || position > (list->tail)){// 检查输入的position下标是否存在
        puts("无效位置！");
        return ;
    }

    Plinklist newNode = (Plinklist)malloc(sizeof(Linklist));//创建一个要插入的新节点
    newNode->data = value;//设置新节点的数据值
    Plinklist current = list;//重新定义一个新指针指向头节点
    int count = 0;//定义一个计数变量
    while(current != NULL && count < position){
        current = current->next;// 找到要插入位置的前一个节点
        count++;
    }

    newNode->next = current->next;// 新节点的后继指向要原删除节点的前一节点的下一个节点
    newNode->prev = current;// 新节点的前驱指向新节点的前一节点
    if (current->next != NULL) {
        current->next->prev = newNode;// 更新原来节点和新节点的连接
    }
    current->next = newNode;// 将新界嗲连接到原节点之后

    list->tail++;
}

5、从双向不循环链表中删除节点：

我们将介绍如何删除链表中的头节点、尾节点和任意节点。这涉及到更新指针和释放节点的内存。
删除头节点：
在这里插入图片描述

// 删除头节点
void deleteHead(Plinklist list){
    if(list ==NULL){
        puts("dalete head arg err");
        return ;
    }

    if(isEmpty(list)){
        puts("表是空的！");
        return;
    }

    Plinklist deleteHead = list->next;// 定义一个新的删除指针指向头节点的下一个节点
    list->next = deleteHead->next;// 头节点的后继更新为要删除节点的后一个后一个节点也可以是list>next = list->next->next）
    if (deleteHead->next != NULL) {
        deleteHead->next->prev = list;// 更新头节点和新节点的连接
    }

    free(deleteHead);//释放删除节点的内存
    list->tail--;// 节点数减一
}

删除尾节点：
在这里插入图片描述

// 删除尾节点
void deleteTail(Plinklist list){
    if(list ==NULL){
        puts("dalete tail arg err");
        return ;
    }

    if(isEmpty(list)){
        puts("表是空的！");
        return;
    }

    Plinklist current = list;
    while(current->next != NULL && current->next->next != NULL){
        current = current->next; 找到尾节点
    }
    Plinklist deleteTail = current->next;
    current->next = NULL;// 要删除节点的上一个节点的后继直接连接NULL，断开要删除节点和NULL的连接
    if (deleteTail != NULL) {// 判断要删除节点是否为空
        free(deleteTail);//不为空则释放该删除节点的内存
        list->tail--;// 节点数减一
    }
}

删除任意下标的节点：
在这里插入图片描述

// 删除指定位置的节点
void deleteAtPosition(Plinklist list, int position){
    if (isEmpty(list)) {
        printf("链表为空，删不了，根本删不了\n");
        return;
    }

    Plinklist current = list;  // 从头节点开始遍历链表，找到要删除节点的前一个节点
    int count = 0;
    while (current->next != NULL && count < position) {
        current = current->next;// 不断更新current指针
        count++;
    }

    if (current->next == NULL) {// 检查删除位置的有效性
        printf("无效的删除位置\n");
        return;
    }

    Plinklist deletePosition = current->next;//定义新的指针记录要删除节点的上一个节点
    current->next = deletePosition->next;// 要删除节点的上一个节点的后继连接到要删除节点的后一个节点，断开要删除节点的和要删除节点
的上一个节点的后继
    if (deletePosition->next != NULL) {
        deletePosition->next->prev = current;//更新前后节点的连接
    }

    free(deletePosition);//释放删除节点的内存
    list->tail--;//节点数减一
    if (isEmpty(list)) {
        printf("链表为空，删不了了，根本删不了了\n");
        return;
    }
}

6、查找链表的元素或元素的下标

我们将介绍和实现按元素下标查找改下标的元素值和按元素的值查找该元素的下标。
按元素的值查找该元素的下标

// 按值查找节点的位置
int findPositionByValue(Plinklist list, typData value){
    if(list ==NULL){
        puts("findValue Position arg err");
        return -1;
    }

    if(isEmpty(list)){
        puts("表是空的！");
        return -1;
    }

    Plinklist current = list->next;
    int position = 0;//定义下标从0开始
    while (current != NULL) {
        if (current->data == value) {
            return position;  // 找到节点的数据值等于目标值，返回节点的下标
        }
        current = current->next;
        position++;
    }
    printf("没有该值！");
    return -1;  // 未找到目标值，返回-1
}

按元素下标查找该下标的元素值

// 按下标查找节点的值
int findValueByPosition(Plinklist list, int position){
    if(list ==NULL){
        puts("findPosition Value arg err");
        return -1;
    }

    if(isEmpty(list)){
        puts("表是空的！");
        return -1;
    }

    Plinklist current = list->next;  // 从第一个节点开始遍历链表
    int count = 0;
    while (current != NULL && count < position) {
        current = current->next;
        count++;
    }

    if (current == NULL) {// 检查下标的有效性
        printf("无效的下标\n");
        return -1;
    }

    return current->data;  // 返回找到的节点的数据值


}

7、修改链表的元素

我们将实现按原值修改新值和按下标修改值
按下标修改值

// 修改指定位置的节点值
void modifyByPosition(Plinklist list, int position, typData value){
    if(list ==NULL){
        puts("modifyPosition Value arg err");
        return ;
    }

    if(isEmpty(list)){
        puts("表是空的！");
        return ;
    }

    if (isEmpty(list)) {
        printf("链表为空，无法修改元素\n");
        return;
    }

    Plinklist current = list->next;  // 从第一个节点开始遍历链表
    int count = 0;
    while (current != NULL && count < position) {
        current = current->next;
        count++;
    }

    if (current == NULL) {
        printf("无效的下标\n");
        return;
    }

    current->data = value;  // 修改节点的数据值
}

按原值修改新值

// 修改指定值的节点值
void modifyValue(Plinklist list, typData oldValue, typData newValue){
    if(list ==NULL){
        puts("modifyValue Value arg err");
        return ;
    }
    if (isEmpty(list)) {
        printf("链表为空，无法修改节点值\n");
        return;
    }

    Plinklist current = list->next;  // 从第一个节点开始遍历链表
    while (current != NULL) {
        if (current->data == oldValue) {
            current->data = newValue;  // 找到节点的数据值等于旧值，更新节点的数据值为新值
            return;
        }
        current = current->next;
    }

    printf("未找到目标值\n");

}

8、获取链表的长度

// 获取链表长度
int getLength(Plinklist list){
    if(isEmpty(list)){
        return -1;
    }
    return list->tail;//直接返回链表的tail节点数

}

9、遍历双向不循环链表：

我们将展示如何遍历链表并访问每个节点的数据元素。我们将演示前向和后向遍历的方法。
向后遍历：从尾节点遍历到头节点

//向后遍历链表并打印节点值（从尾节点遍历到头节点）
void prev_traverse(Plinklist list){
    if(list == NULL){
        puts("prev_traverse arg err");
        return ;
    }
    if(isEmpty(list)){
        return ;
    }
    Plinklist current_tail = list;
    while(current_tail->next != NULL){
        current_tail = current_tail->next;// 找到尾节点
    }
    Plinklist current = current_tail;
    while(current != list){
        printf("%d ",current->data);// 打印节点值
        current = current->prev;
    }
    printf("\n");

}

向前遍历：从头节点遍历到尾节点

//向前遍历链表并打印节点值（从头节点遍历到尾节点）
void next_traverse(Plinklist list){
    if(list == NULL){
        puts("next_traverse arg err");
        return ;
    }
    if(isEmpty(list)){
        return ;
    }

    Plinklist current = list->next;

    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}

10、释放双向不循环链表的内存：

我们将讨论如何正确释放整个链表所占用的内存。
我们调用前面的删除头节点的方法。不断删除头节点直到链表为空
在这里插入图片描述

// 清空链表
void clearList(Plinklist list){
    while(list->next != NULL){
        deleteHead(list);//调用删除头节点函数，实现不断的删除头节点
    }
    printf("表已被清空！\n");
}

完整代码

分三个文件进行，①接口文件blinklist.h、②blinklist.c、③blinklist_main.c

①blinklist.h

#ifndef _BLINKLIST_H_
#define _BLINKLIST_H_
#include <stdio.h>
#include <stdlib.h>

typedef int typData;

// 链表节点结构体
typedef struct Node {
    typData data;// 节点数据
    int tail;//记录节点数
    struct Node *prev;//指向下一个节点的指针
    struct Node *next;//指向下一个节点的指针
} Linklist, *Plinklist;

// 创建链表
Plinklist createLinkedList(Plinklist *list);

// 判断链表是否为空
int isEmpty(Plinklist list);

// 在链表头部插入元素
void insertAtHead(Plinklist list, typData value);

// 在链表尾部插入元素
void insertAtTail(Plinklist list, typData value);

// 在指定位置插入元素
void insertAtPosition(Plinklist list, int position, typData value);

// 删除头节点
void deleteHead(Plinklist list);

// 删除尾节点
void deleteTail(Plinklist list);

// 删除指定位置的节点
void deleteAtPosition(Plinklist list, int position);

// 按值查找节点的位置
int findPositionByValue(Plinklist list, typData value);

// 按下标查找节点的值
int findValueByPosition(Plinklist list, int position);

// 修改指定位置的节点值
void modifyByPosition(Plinklist list, int position, typData value);

// 修改指定值的节点值
void modifyValue(Plinklist list, typData oidValue, typData newValue);

// 获取链表长度
int getLength(Plinklist list);

// 向前遍历链表并打印节点值
void prev_traverse(Plinklist list);

// 向后遍历链表并打印节点值
void next_traverse(Plinklist list);

// 清空链表
void clearList(Plinklist list);

#endif

②blinklist.c

#include "blinklist.h"
/*
// 链表节点结构体
typedef struct Node {
    typData data;// 节点数据
    int tail;//记录节点数
    struct Node *prev;//指向上一个节点的指针
    struct Node *next;//指向下一个节点的指针
} Linklist, *Plinklist;
*/

// 创建链表
Plinklist createLinkedList(Plinklist *list){
    (*list) = (Plinklist)malloc(sizeof(Linklist));//为表头申请空间
    if(list == NULL){
        perror("createLinkedList list malloc");
    }
    (*list)->tail = 0;//记录节点数
    (*list)->prev = NULL;//头节点的上一个节点置空
    (*list)->next = NULL;//头节点的下一个节点置空
    return *list;
}

// 判断链表是否为空
int isEmpty(Plinklist list){
    if(list == NULL || list->tail == 0){
        //puts("表是空的！");
        return 1;//真空
    }else{
        return 0;//非空
    }
}


// 在链表头部插入元素
void insertAtHead(Plinklist list, typData value){
    if(list == NULL){
        puts("insert head arg err");
        return ;
    }

    Plinklist newNode = (Plinklist)malloc(sizeof(Linklist));
    if(newNode == NULL){
        perror("insert head newNode malloc");//头插入内存分配失败
        return ;
    }

    newNode->data = value;//设置新节点的数据值
    newNode->prev = list;//新节点的prev指针指向头节点
    newNode->next = list->next;//新节点的next指针的作用是替代头节点的next指针指向NULL
    if(list->next != NULL){
        list->next->prev = newNode;更新头节点的前驱节点为新节点
    }
    list->next = newNode;//更新头节点的后继节点为新节点
    list->tail++;//链表长度加一
}


// 在链表尾部插入元素
void insertAtTail(Plinklist list, typData value){
    if(list == NULL){
        puts("insert tail arg err");
        return ;
    }
    Plinklist newNode = (Plinklist)malloc(sizeof(Linklist));
    if(newNode == NULL){
        perror("insert tail newNode malloc");
        return ;
    }
    newNode->data = value;// 设置新节点的数据值
    newNode->next = NULL;// 新节点的后继节点指向NULL

    Plinklist current_tail = list;// 重新定义一个新指针指向头节点
    while(current_tail->next != NULL){
        current_tail = current_tail->next;// 遍历找到链表的尾节点
    }

    newNode->prev = current_tail;// 新节点的前驱节点指向尾节点
    current_tail->next = newNode;// 尾节点的后继节点指向新节点

    list->tail++;// 节点数加一

}


// 在指定位置插入元素
void insertAtPosition(Plinklist list, int position, typData value){
    if(list ==NULL){
        puts("insert position arg err");
        return ;
    }

    if(position < 0 || position > (list->tail)){// 检查输入的position下标是否存在
        puts("无效位置！");
        return ;
    }

    Plinklist newNode = (Plinklist)malloc(sizeof(Linklist));//创建一个要插入的新节点
    newNode->data = value;//设置新节点的数据值
    Plinklist current = list;//重新定义一个新指针指向头节点
    int count = 0;//定义一个计数变量
    while(current != NULL && count < position){
        current = current->next;// 找到要插入位置的前一个节点
        count++;
    }

    newNode->next = current->next;// 新节点的后继指向要原删除节点的前一节点的下一个节点
    newNode->prev = current;// 新节点的前驱指向新节点的前一节点
    if (current->next != NULL) {
        current->next->prev = newNode;// 更新原来节点和新节点的连接
    }
    current->next = newNode;// 将新界嗲连接到原节点之后

    list->tail++;
}


// 删除头节点
void deleteHead(Plinklist list){
    if(list ==NULL){
        puts("dalete head arg err");
        return ;
    }

    if(isEmpty(list)){
        puts("表是空的！");
        return;
    }
    Plinklist deleteHead = list->next;// 定义一个新的删除指针指向头节点的下一个节点
    list->next = deleteHead->next;// 头节点的后继更新为要删除节点的后一个后一个节点（也可以是list>next = list->next->next）
    if (deleteHead->next != NULL) {
        deleteHead->next->prev = list;// 更新头节点和新节点的连接
    }

    free(deleteHead);//释放删除节点的内存
    list->tail--;// 节点数减一
}


// 删除尾节点
void deleteTail(Plinklist list){
    if(list ==NULL){
        puts("dalete tail arg err");
        return ;
    }

    if(isEmpty(list)){
        puts("表是空的！");
        return;
    }

    Plinklist current = list;
    while(current->next != NULL && current->next->next != NULL){
        current = current->next; 找到尾节点
    }
    Plinklist deleteTail = current->next;
    current->next = NULL;// 要删除节点的上一个节点的后继直接连接NULL，断开要删除节点和NULL的连接
    if (deleteTail != NULL) {// 判断要删除节点是否为空
        free(deleteTail);//不为空则释放该删除节点的内存
        list->tail--;// 节点数减一
    }
}


// 删除指定位置的节点
void deleteAtPosition(Plinklist list, int position){
    if (isEmpty(list)) {
        printf("链表为空，删不了，根本删不了\n");
        return;
    }

    Plinklist current = list;  // 从头节点开始遍历链表，找到要删除节点的前一个节点
    int count = 0;
    while (current->next != NULL && count < position) {
        current = current->next;// 不断更新current指针
        count++;
    }

    if (current->next == NULL) {// 检查删除位置的有效性
        printf("无效的删除位置\n");
        return;
    }

    Plinklist deletePosition = current->next;//定义新的指针记录要删除节点的上一个节点
    current->next = deletePosition->next;// 要删除节点的上一个节点的后继连接到要删除节点的后一个节点，断开要删除节点的和要删除节点的上一个节点的后继
    if (deletePosition->next != NULL) {
        deletePosition->next->prev = current;//更新前后节点的连接
    }

    free(deletePosition);//释放删除节点的内存
    list->tail--;//节点数减一
    if (isEmpty(list)) {
        printf("链表为空，删不了了，根本删不了了\n");
        return;
    }
}


// 按值查找节点的位置
int findPositionByValue(Plinklist list, typData value){
    if(list ==NULL){
        puts("findValue Position arg err");
        return -1;
    }

    if(isEmpty(list)){
        puts("表是空的！");
        return -1;
    }

    Plinklist current = list->next;
    int position = 0;//定义下标从0开始
    while (current != NULL) {
        if (current->data == value) {
            return position;  // 找到节点的数据值等于目标值，返回节点的下标
        }
        current = current->next;
        position++;
    }
    printf("没有该值！");
    return -1;  // 未找到目标值，返回-1
}


// 按下标查找节点的值
int findValueByPosition(Plinklist list, int position){
    if(list ==NULL){
        puts("findPosition Value arg err");
        return -1;
    }

    if(isEmpty(list)){
        puts("表是空的！");
        return -1;
    }

    Plinklist current = list->next;  // 从第一个节点开始遍历链表
    int count = 0;
    while (current != NULL && count < position) {
        current = current->next;
        count++;
    }

    if (current == NULL) {// 检查下标的有效性
        printf("无效的下标\n");
        return -1;
    }

    return current->data;  // 返回找到的节点的数据值
}

// 修改指定位置的节点值
void modifyByPosition(Plinklist list, int position, typData value){
    if(list ==NULL){
        puts("modifyPosition Value arg err");
        return ;
    }

    if(isEmpty(list)){
        puts("表是空的！");
        return ;
    }

    if (isEmpty(list)) {
        printf("链表为空，无法修改元素\n");
        return;
    }

    Plinklist current = list->next;  // 从第一个节点开始遍历链表
    int count = 0;
    while (current != NULL && count < position) {
        current = current->next;
        count++;
    }

    if (current == NULL) {
        printf("无效的下标\n");
        return;
    }

    current->data = value;  // 修改节点的数据值
}


// 修改指定值的节点值
void modifyValue(Plinklist list, typData oldValue, typData newValue){
    if(list ==NULL){
        puts("modifyValue Value arg err");
        return ;
    }
    if (isEmpty(list)) {
        printf("链表为空，无法修改节点值\n");
        return;
    }

    Plinklist current = list->next;  // 从第一个节点开始遍历链表
    while (current != NULL) {
        if (current->data == oldValue) {
            current->data = newValue;  // 找到节点的数据值等于旧值，更新节点的数据值为新值
            return;
        }
        current = current->next;
    }

    printf("未找到目标值\n");

}

// 获取链表长度
int getLength(Plinklist list){
    if(isEmpty(list)){
        return -1;
    }
    return list->tail;

}


//向后遍历链表并打印节点值（从尾节点遍历到头节点）
void prev_traverse(Plinklist list){
    if(list == NULL){
        puts("prev_traverse arg err");
        return ;
    }
    if(isEmpty(list)){
        return ;
    }
    Plinklist current_tail = list;
    while(current_tail->next != NULL){
        current_tail = current_tail->next;// 找到尾节点
    }
    Plinklist current = current_tail;
    while(current != list){
        printf("%d ",current->data);// 打印节点值
        current = current->prev;
    }
    printf("\n");

}


//向前遍历链表并打印节点值（从头节点遍历到尾节点）
void next_traverse(Plinklist list){
    if(list == NULL){
        puts("next_traverse arg err");
        return ;
    }
    if(isEmpty(list)){
        return ;
    }

    Plinklist current = list->next;

    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    printf("\n");
}

// 清空链表
void clearList(Plinklist list){
    while(list->next != NULL){
        deleteHead(list);//调用删除头节点函数，实现不断的删除头节点
    }
    printf("表已被清空！\n");
}

③blinklist_main.c

#include "blinklist.h"
#include "blinklist.c"

int main() {
    Plinklist list;
    createLinkedList(&list);

    int choice, value, position, oldValue, newValue;

    while (1) {
        printf("\n*****************************链表操作菜单*****************************\n");
        printf("1. 在头部插入元素           2. 在尾部插入元素           3. 在任意位置插入元素\n");
        printf("4. 删除头节点               5. 删除尾节点               6. 删除任意位置的节点\n");
        printf("7. 按值查找元素的位置       8. 按位置查找元素的值       9. 修改指定位置的节点值\n");
        printf("10. 修改指定值的节点值      11. 获取链表长度            12. 遍历链表\n");
        printf("13. 清空链表                14. 退出程序\n");
        printf("*********************************************************************\n");
        printf("请输入操作编号：");
        scanf("%d", &choice);

        switch (choice) {
            case 1:
                printf("请输入要插入的元素值：");
                scanf("%d", &value);
                insertAtHead(list, value);
                printf("向后遍历：");
                prev_traverse(list);
                printf("向前遍历：");
                next_traverse(list);
                break;
            case 2:
                printf("请输入要插入的元素值：");
                scanf("%d", &value);
                insertAtTail(list, value);
                printf("向后遍历：");
                prev_traverse(list);
                printf("向前遍历：");
                next_traverse(list);
                break;
            case 3:
                printf("请输入要插入的位置：");
                scanf("%d", &position);
                printf("请输入要插入的元素值：");
                scanf("%d", &value);
                insertAtPosition(list, position, value);
                printf("向后遍历：");
                prev_traverse(list);
                printf("向前遍历：");
                next_traverse(list);
                break;
            case 4:
                deleteHead(list);
                printf("向后遍历：");
                prev_traverse(list);
                printf("向前遍历：");
                next_traverse(list);
                break;
            case 5:
                deleteTail(list);
                printf("向后遍历：");
                prev_traverse(list);
                printf("向前遍历：");
                next_traverse(list);
                break;
            case 6:
                printf("请输入要删除的位置：");
                scanf("%d", &position);
                deleteAtPosition(list, position);
                printf("向后遍历：");
                prev_traverse(list);
                printf("向前遍历：");
                next_traverse(list);
                break;
            case 7:
                printf("请输入要查找的元素值：");
                scanf("%d", &value);
                position = findPositionByValue(list, value);
                if (position != -1) {
                    printf("元素值 %d 的位置是：%d\n", value, position);
                }
                break;
            case 8:
                printf("请输入要查找的位置：");
                scanf("%d", &position);
                value = findValueByPosition(list, position);
                if (value != -1) {
                    printf("位置 %d 上的元素值是：%d\n", position, value);
                }
                break;
            case 9:
                printf("请输入要修改的位置：");
                scanf("%d", &position);
                printf("请输入修改后的元素值：");
                scanf("%d", &value);
                modifyByPosition(list, position, value);
                printf("向后遍历：");
                prev_traverse(list);
                printf("向前遍历：");
                next_traverse(list);
                break;
            case 10:
                printf("请输入要修改的元素值：");
                scanf("%d", &oldValue);
                printf("请输入修改后的元素值：");
                scanf("%d", &newValue);
                modifyValue(list, oldValue, newValue);
                printf("向后遍历：");
                prev_traverse(list);
                printf("向前遍历：");
                next_traverse(list);
                break;
            case 11:
                printf("链表的长度是：%d\n", getLength(list));
                break;
            case 12:
                printf("向后遍历：");
                prev_traverse(list);
                printf("向前遍历：");
                next_traverse(list);
                break;
            case 13:
                clearList(list);
                break;
            case 14:
                printf("已退出！！\n");
                exit(0);
            default:
                printf("无效的操作编号！\n");
                break;
        }
    }
    return 0;
}
小羊客栈
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
不循环的双向链表
qq_59961968的博客
08-27 371
做初学者，我将向读者介绍如何去创建一个双向链表，和实现一些简单的功能
双向链表（非循环）
MOON5555的博客
10-30 2258
1、头文件(dilst.h) #pragma once //带头结点的双向链表(非循环) typedef struct DNode { int data;//数据域 struct DNode *next;//后继指针 struct DNode *prio;//前驱指针 }DNode,*DList; //初始化双向链表 void InitDList(DList plist); //头插
数据结构、手写双向非循环链表
lsplook的博客
08-22 141
Java中数组是对线性结构，也是顺序存储结构的具体实现。Java中数组会在内存中开辟大小固定，地址连续的空间，数组中的数据具有从前往后的顺序。1.链表的存储分类为链式结构，非连续的空间。2.链表第一个节点称为头节点，最后一个节点称为尾节点。栈（Stack）是一种存储受限的线性结构。其具体实现可以用链表或数组。栈只允许从一侧进行操作数据，这侧称为栈顶（top）。另一侧称为栈底(bottom)。往栈中放入元素的过程称为：入栈（push）。从栈中删除元素的过程称为：出栈（pop）。先进后出。
线性表 - 双链表（非循环）
小神兵之技术篇
07-15 770
S1双链表定义1）双（向）链表中有两条方向不同的链，即每个节点中除next域存放后继结点地之外，还增加一个指向其直接前驱的指针域prior。2）哨兵节点时隔哑对象，可以简化边界条件。S2双链表前插与删除节点操作1）双向链表的前插操作。（由于双链表的对称性，在双链表中能完成各种插入
链表的遍历、插入、删除、清空、销毁操作
qq_45432387的博客
05-03 3866
一、在这里链表的基本操作包括以下几点： 1.初始化链表：输入-1退出链表，输入其他值写入链表 2.遍历链表：打印输入的数字 3.插入链表：插入链表的基本思想为 1）创建指针pCurrent指向要查找的数字 2）初见前置指针pPrve指向查找数字的前一级 3）插入后建立指针关系，即插入的新数字的指针newNode指向查找数字的指针pCurrent，查找数字的前一级的指针pPrve指向插入的新数字的指针newNoded newNode->next = pCurrent; pPrve-&
test3-插入.rar_尾插法_有头插法_链表 插入创建
09-20
链表 插入创建，有头插法，尾插法，入门级的，供实验使用
头插法、尾插法、链表长度test-c-master.zip
04-17
头插法、尾插法、链表长度test_c-master.zip
头插法（Head Insertion Method）是一种链表插入操作的方法
最新发布
04-17
头插法
单链表的基本操作头插法尾插法创建插入删除遍历
12-08
单链表的基本操作，单链表头插法、尾插法、创建、插入、删除、遍历
C语言实现带头结点的链表的创建、查找、插入、删除操作
09-04
带头结点的链表是指链表的第一个元素是一个特殊的节点，通常称为头结点，它的数据域不存储实际的数据，而是用于存放指向第一个实际数据节点的指针。这种设计方便了链表的操作，尤其是对链表的创建、查找、插入和删除...
P9 链表 清空链表|销毁链表
weixin_73901182的博客
12-04 1361
🎬 个人主页：@ChenPi🐻推荐专栏1: 《》✨✨✨🔥 推荐专栏2: 《》✨✨✨📝推荐专栏3: ​​​​​​《》 ✨✨✨🍉本篇简介 : 链表清空链表|销毁链表✨ 只有我努力了 才有机会接触成功✨链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。链表都有一个头指针，一般以head来表示，存放的是一个地址。
单链表与双链表，常见的插入和删除
yhm12580的博客
07-31 1415
else {} }这段代码是一个用于将元素插入单链表末尾的函数。函数的定义是 void SlistPushBack(SlistNode** pphead, SlistDateType x)，它接受两个参数：一个指向单链表头指针的指针 pphead 和要插入的元素值 x。首先，代码中使用 malloc 函数为新节点分配内存空间 sizeof(SlistNode)，并将返回的指针赋值给 newnode 变量。
数据结构（王卓）（4）附：链表的销毁与清空
Zz_zzzzzzz__的博客
12-03 3091
另外，如果我们在输入的时候，输入一个链表Lnode类型进去： 或者： 清空（只销毁内容） project 1：（其实只是对销毁链表的生搬硬套的照抄，并且里面还缺少了while语句的循环） project 2： 结果他说清空链表是指清空中间的所有结点，但是保留头结点（也包括头指针）（为空）而不是清空链表中每一结点存储的数据内容，remake：project 3： 整个程序运行的流程逻辑链路还是没有完成闭环project 4： 注意：在这里，我们不能再用L来指向第二个节点的地址，因为
【数据结构】双向链表(思路解释，插入，删除，打印. c++代码)
Swillow_的博客
09-06 618
到双向链表咯，链表的知识终于走到最终章了hhh(视频教程只到这些知识视频课程地址：👇。
双向链表的删除和插入
热门推荐
m0_61395860的博客
02-05 1万+
一、初始操作 双向链表定义如下： #include<stdio.h> #include<stdlib.h> typedef struct DLnode{ int data; struct DLnode *prev,*next; }DLnode,*DLinklist; 尾插法创建： void Create(DLinklist &L){ L=(DLinklist)malloc(sizeof(DLnode)); L->next=NULL; D
阻塞队列LinkedBlockingQueue源码学习与对比
IT乐知
09-14 182
前上一篇详细学习了ArrayBlockingQueue，今天学习LinkedBlockingQueue源码并与之对比。
数据结构学习系列之单向链表的清空与销毁
qq_41878292的博客
09-04 1184
【代码】数据结构学习系列之单向链表的清空与销毁。
清空链表的算法
weixin_52634719的博客
09-19 2463
思路：从首元结点依次将所有结点释放掉，头结点后面没有元素后，将头结点的指针域设置为空。 p=L.next，p指向首元结点,但不能直接释放首元节点。要先把下一个结点记录下来 那就用另一个变量q，指向要释放掉结点的下一个结点 q指针变量要存储的是第二个结点的地址，他在第一个结点的next域里存着，只需将第一个结点的Next域赋值给他，就可以指向第二结点了。第一个结点的Next域是指针变量p所指的这一结点的Next域，所以将p的next域赋值给q，就是将下一结点的地址赋值给...
c 语言单向链表的删除
比雅尼·斯特劳斯特鲁普（Bjarne Stroustrup）曾说过：如果你没看过这些博客，那么你的编程不会拥有智慧，你的代码不可能附有灵魂。
08-30 1957
单链表删除
双向循环链表有头插法尾插法吗
05-22
双向循环链表同样可以使用头插法和尾插法进行插入操作。 使用头插法时，新节点插入在链表头部，需要进行以下操作： 1. 创建新节点； 2. 将新节点的next指针指向原来的头节点； 3. 将新节点的prev指针指向原来的头节点的上一个节点； 4. 将原来的头节点的prev指针指向新节点； 5. 将链表的头节点指向新节点。 使用尾插法时，新节点插入在链表尾部，需要进行以下操作： 1. 创建新节点； 2. 将新节点的prev指针指向原来的尾节点； 3. 将新节点的next指针指向原来的尾节点的下一个节点（即头节点）； 4. 将原来的尾节点的next指针指向新节点； 5. 将链表的尾节点指向新节点。 需要注意的是，双向循环链表的头节点和尾节点是相互指向的，因此在进行插入操作时需要特别处理。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小羊客栈

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

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

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

打赏作者

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

抵扣说明：

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

余额充值