数据结构04--双向循环链表详解

已于 2024-08-09 10:58:57 修改
阅读量449 收藏 3
点赞数 12
分类专栏： 数据结构 C语言 文章标签： 数据结构 链表 算法
于 2024-08-09 10:22:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_69902486/article/details/141052178
版权

1. 概念        

        对链表而言，双向均可遍历是最方便的，另外首尾相连循环遍历也可大大增加链表操作的便捷性。因此，双向循环链表，是在实际运用中是最常见的链表形态。

2. 基本操作

与普通的链表完全一致，双向循环链表虽然指针较多，但逻辑是完全一样。基本的操作包括：

2.1链表节点设计:

// 设计节点数据域
typedef struct data
{
    int num;
    char name[30];
} data_t;

// 设计链表节点
typedef struct node
{
    data_t data;       // 链表数据域
    struct node *prev; // 链表前驱节点
    struct node *next; // 链表后继节点
} node_t, *P_node_t;

2.2链表节点初始化：

/// @brief 初始化链表节点
/// @param data 节点数据地址
P_node_t nodeInit(data_t *data)
{
    // 在堆内存空间中申请新节点空间
    P_node_t newNode = (P_node_t)calloc(1, sizeof(node_t));
    // 判断是否申请成功
    if (newNode == NULL)
    {
        perror("CALLOC ERROR");
        return NULL;
    }

    // 函数接口设计巧妙之处：设计data_t*的形参类型
    // 当传入数据为NULL,表示要初始化节点为头节点,头节点数据无需初始化
    // 当传入数据不为NULL,表示要初始化节点为有效节点,则初始化节点数据
    if (data != NULL)
    {
        memcpy(&newNode->data, data, sizeof(data_t));
    }

    newNode->prev = newNode->next = newNode;

    return newNode;
}

2.3链表节点头插：

/// @brief 将节点头插到链表中
/// @param head 链表头节点
/// @param newNode 新节点
/// @return 返回头插完成的链表头节点
P_node_t addListHead(P_node_t head, P_node_t newNode)
{
    // 头插要考虑到链表中有无有效节点的情况

    // 新节点的next指针指向头节点之后的链表,防止链表丢失
    newNode->next = head->next;
    // 新节点的prev指针指向头节点
    newNode->prev = head;

    // 头节点的next指针指向新节点
    head->next = newNode;
    // 头节点之后的有效节点的prev指针指向新节点
    // 因为head->next已改变,所以这里用newNode->next索引头节点之后的节点
    newNode->next->prev = newNode;

    // 返回头插完成的链表头节点
    return head;
}

2.4链表节点尾插:

P_node_t addListTail(P_node_t head, P_node_t newNode)
{
    // 尾插要考虑到链表中有无有效节点的情况

    // 新节点的next指针指向head头节点
    newNode->next = head;
    // 新节点的prev指针指向链表最后一个节点,即head的前驱节点
    newNode->prev = head->prev;

    // head的前驱节点的next指针指向newNode
    head->prev->next = newNode;
    // head的prev指针指向newNode
    head->prev = newNode;

    // 返回尾插后的链表头节点更新链表
    return head;
}

//链表节点尾插也可以用头插函数,只是传参的巧妙设计
// 将节点尾插插入到链表中
// 使用头插函数,将newNode插入到head的前继节点后即尾插
// 注意这里不能更新head,因为传进去是head->prev
// addListHead(head->prev, newNode);

2.5链表节点有序插入:

/// @brief 将节点有序插入到链表中
/// @param head 链表头节点
/// @param newNode 新节点
/// @return 返回尾插完成后的链表头节点更新链表
P_node_t addListOrder(P_node_t head, P_node_t newNode)
{
    P_node_t tmp = NULL;
    // tmp遍历链表节点,newNode插入到合适位置的后继节点,
    // 所以tmp从head开始,遍历到tmp==head结束
    for (tmp = head; tmp->next != head; tmp = tmp->next)
    {
        // 当tmp的后继节点的数据大于新节点的数据时,tmp寻找到合适的位置插入
        if (tmp->next->data.num > newNode->data.num)
        {
            break;
        }
    }

    // 此时跳出循环,有两种结果：
    // 一是链表的节点数据都比newNode的数据小,tmp遍历到链表最后一个节点

    // 二是tmp遍历到合适的位置插入

    // 新节点的next指向tmp的next,防止后面的链表丢失
    newNode->next = tmp->next;
    // 新节点的prev指向tmp
    newNode->prev = tmp;
    // tmp的next指向newNode
    tmp->next = newNode;
    // 新节点的后继节点的prev指向新节点
    // 因为tmp->next已经改变,所以通过newNode->next索引到后继节点
    newNode->next->prev = newNode;

    // 返回有序插入之后的链表头节点
    return head;
}

2.6链表寻找中间节点:

/// @brief 查找链表的中间节点
/// @param head 链表头节点
/// @return 返回链表的中间节点
P_node_t findMiddleNode(P_node_t head)
{
    //判断链表是否为空
    if (isListEmpty(head))
    {
        printf("链表为空.\n");
        return NULL;
    }
    //快慢指针遍历链表
    //slow链表每次遍历一个节点
    //quick链表每次遍历两个节点
    P_node_t slow = head->next;
    P_node_t quick = head->next;

    //当quick到达链表末尾时,slow指针刚好到达链表中间节点
    //因为quick指针每次遍历是两个节点,所以判断quick和quick->next是否等于head
    while (quick != head && quick->next != head)
    {
        //slow指针每次遍历一个节点
        slow = slow->next;
        //quick指针每次遍历两个节点
        quick = quick->next->next;
    }
    //跳出循环时quick或者quick->next到达链表尾
    //此时slow指向链表中间节点

    //返回链表中间节点
    return slow;
}

2.7判断链表是否为空：

/// @brief 判断链表是否有有效节点
/// @param head 链表头节点
/// @return 链表无有效节点返回真,有有效节点返回假
bool isListEmpty(P_node_t head)
{
    // 判断链表有效节点是否为空
    return (head->next == head);
}

2.8链表遍历:

/// @brief 遍历打印链表的数据
/// @param head 链表头节点
void display(P_node_t head)
{
    // 判断链表是否为空
    if (isListEmpty(head))
    {
        printf("链表为空.\n");
        return;
    }
    // tmp遍历链表每一个节点,所以tmp从有效节点开始,到tmp==head结束
    for (P_node_t tmp = head->next; tmp != head; tmp = tmp->next)
    {
        printf("[%d]:%s\n", tmp->data.num, tmp->data.name);
    }

    return;
}

2.9链表节点查找：

/// @brief 查找匹配数据的节点
/// @param head 链表头节点
/// @param findData 要查找的数据
/// @return 查找成功返回查找到的节点地址,查找失败返回
P_node_t findListNode(P_node_t head, int findData)
{
    // 判读链表是否为空
    if (isListEmpty(head))
    {
        printf("链表为空.\n");
        return NULL;
    }
    P_node_t tmp = NULL, findNode = NULL;
    // tmp从链表有效节点开始遍历链表每一个节点
    for (tmp = head->next; tmp != head; tmp = tmp->next)
    {
        // 如果匹配数据,就存储tmp指向的节点地址
        if (tmp->data.num == findData)
        {
            findNode = tmp;
            break;
        }
    }
    // 此时findNode有两种情况:
    // 一是：未查找到匹配的节点,findNode为NULL
    // 二是：查找到匹配的节点,findNode不为NULL

    // 返回查找的结果
    return findNode;
}

2.10链表节点数据修改：

/// @brief 修改链表节点数据
/// @param head 链表头节点
/// @param findData 要修改节点的数据
/// @return 成功返回修改成功的节点,失败返回NULL
P_node_t reviseListNode(P_node_t head, int findData)
{
    //查找要修改数据的节点
    P_node_t reviseNode = findListNode(head, findData);
    //判断是否查找到要修改数据的节点
    if (reviseNode == NULL)
    {
        printf("查找不到要修改数据的节点.\n");
        return NULL;
    }
    printf("请输入要修改的编号名字.\n");
    
    scanf("%d%s", &reviseNode->data.num, reviseNode->data.name);

    //返回修改完成的节点
    return reviseNode;
}

2.11链表节点剔除:

/// @brief 将节点从链表中剔除下来
/// @param head 链表头节点
/// @param delData 要剔除节点的数据
/// @return 剔除下来的节点
P_node_t delListNode(P_node_t head, int delData)
{
    P_node_t delNode = NULL;
    //在链表中寻找要剔除的节点
    delNode = findListNode(head, delData);
    //判断是否查找到要剔除的节点
    if (delNode == NULL)
    {
        printf("未查找到要删除的节点.\n");
        return NULL;
    }

    //要剔除节点的前驱节点的next指针指向要剔除节点的后继节点
    delNode->prev->next = delNode->next;
    //要剔除节点的后继节点的prev指针指向要剔除节点的前驱节点
    delNode->next->prev = delNode->prev;
    //将要剔除节点的next和prev指针指向自己,节点从链表中剔除下来
    delNode->next = delNode->prev = delNode;

    //返回剔除下来的节点
    return delNode;
}

2.12链表插入排序:

/// @brief 插入排序链表
/// @param head 插入排序完成的链表头节点
void insertSort(P_node_t head)
{
    //判断链表是否为空
    if (isListEmpty(head))
    {
        //链表为空不需要排序
        printf("链表为空,无需排序.\n");
        return;
    }

    P_node_t outTmp = NULL, inTmp = NULL, insertNode = NULL;
    // 外循环outTmp遍历链表每一个节点进行插入排序
    for (outTmp = head->next; outTmp != head;)
    {
        //insertNode指向要插入的节点
        insertNode = outTmp;
        //内循环inTmp遍历要插入节点前的链表,寻找合适的位置来插入
        //插入需要前驱节点,所以inTmp从head开始,inTmp遍历到要插入节点的前驱节点结束
        for (inTmp = head; inTmp->next != insertNode; inTmp = inTmp->next)
        {
            //inTmp寻找到合适的位置插入,跳出循环
            if (inTmp->next->data.num > insertNode->data.num)
            {
                break;
            }
        }

        // 此时跳出循环,有两种情况:
        // 一是：要插入节点前的链表节点数据都比要插入节点数据小
        //此时要插入节点就在合适的位置上
        if (inTmp->next == insertNode)
        {   
            //更新outTmp往后遍历
            outTmp = outTmp->next;
            continue;
        }


        //二是：inTmp寻找到合适位置插入

        //更新outTmp往后遍历
        outTmp = outTmp->next;


        // 把insertNode节点从链表中剔除下来
        //insertNode的前驱节点的next指针指向insertNode的后继节点
        insertNode->prev->next = insertNode->next;
        //insertNode的后继节点的prev指针指向insertNode的前驱节点
        insertNode->next->prev = insertNode->prev;
        //insertNode的next和prev指针指向自己,节点从链表中剔除下来
        insertNode->next = insertNode->prev = insertNode;


        //insertNode插入到inTmp节点之后
        //insertNode的next指针指向inTmp的后继节点
        insertNode->next = inTmp->next;
        //insertNode的prev指向inTmp
        insertNode->prev = inTmp;
        //insertNode的前驱节点inTmp的next指针指向insertNode
        inTmp->next = insertNode;
        //insertNode的后继节点的prev指向insertNode
        insertNode->next->prev = insertNode;

    }

    return;
}

2.13链表销毁:

/// @brief 销毁链表,释放链表节点申请的堆内存空间
/// @param head 链表头节点
void destoryList(P_node_t head)
{
    P_node_t tmp = NULL,tmpPrev = NULL;
    //tmp遍历链表有效结点,tmpPrev销毁链表节点
    for (tmp= head->next;tmp!=head;)
    {
        //tmpPrev指向要销毁的节点
        tmpPrev = tmp;
        //tmp往后遍历
        tmp = tmp->next;
        //释放tmpPrev的堆内存空间
        free(tmpPrev);
    }
    //tmp指向头节点时跳出循环,此时头节点堆内存空间还未释放
    free(tmp);

    return;
}

2.14判断堆内存空间是否全部释放:

ubuntu下运行代码加上运行命令valgrind ./a.out ,如命令行提示未知命令,则需要先安装valgrind

3.链表代码示例:

/**
 * 双向循环链表
 */
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>

// 设计节点数据域
typedef struct data
{
    int num;
    char name[30];
} data_t;

// 设计链表节点
typedef struct node
{
    data_t data;       // 链表数据域
    struct node *prev; // 链表前驱节点
    struct node *next; // 链表后继节点
} node_t, *P_node_t;

/// @brief 初始化链表节点
/// @param data 节点数据地址
P_node_t nodeInit(data_t *data)
{
    // 在堆内存空间中申请新节点空间
    P_node_t newNode = (P_node_t)calloc(1, sizeof(node_t));
    // 判断是否申请成功
    if (newNode == NULL)
    {
        perror("CALLOC ERROR");
        return NULL;
    }

    // 函数接口设计巧妙之处：设计data_t*的形参类型
    // 当传入数据为NULL,表示要初始化节点为头节点,头节点数据无需初始化
    // 当传入数据不为NULL,表示要初始化节点为有效节点,则初始化节点数据
    if (data != NULL)
    {
        memcpy(&newNode->data, data, sizeof(data_t));
    }

    newNode->prev = newNode->next = newNode;

    return newNode;
}

/// @brief 判断链表是否有有效节点
/// @param head 链表头节点
/// @return 链表无有效节点返回真,有有效节点返回假
bool isListEmpty(P_node_t head)
{
    // 判断链表有效节点是否为空
    return (head->next == head);
}

/// @brief 获得新数据
/// @return 返回获得的新数据
data_t getData()
{
    data_t newData = {0};
    printf("请输入编号名字.\n");
    while(scanf("%d%s",&newData.num,newData.name)!=2)
    {
        printf("输入错误,请重新输入.\n");
        while(getchar()!='\n');
        continue;
    }
    return newData;
}

/// @brief 将节点头插到链表中
/// @param head 链表头节点
/// @param newNode 新节点
/// @return 返回头插完成的链表头节点
P_node_t addListHead(P_node_t head, P_node_t newNode)
{
    // 头插要考虑到链表中有无有效节点的情况

    // 新节点的next指针指向头节点之后的链表,防止链表丢失
    newNode->next = head->next;
    // 新节点的prev指针指向头节点
    newNode->prev = head;

    // 头节点的next指针指向新节点
    head->next = newNode;
    // 头节点之后的有效节点的prev指针指向新节点
    // 因为head->next已改变,所以这里用newNode->next索引头节点之后的节点
    newNode->next->prev = newNode;

    // 返回头插完成的链表头节点
    return head;
}

P_node_t addListTail(P_node_t head, P_node_t newNode)
{
    // 尾插要考虑到链表中有无有效节点的情况

    // 新节点的next指针指向head头节点
    newNode->next = head;
    // 新节点的prev指针指向链表最后一个节点,即head的前驱节点
    newNode->prev = head->prev;

    // head的前驱节点的next指针指向newNode
    head->prev->next = newNode;
    // head的prev指针指向newNode
    head->prev = newNode;

    // 返回尾插后的链表头节点更新链表
    return head;
}

/// @brief 将节点有序插入到链表中
/// @param head 链表头节点
/// @param newNode 新节点
/// @return 返回尾插完成后的链表头节点更新链表
P_node_t addListOrder(P_node_t head, P_node_t newNode)
{
    P_node_t tmp = NULL;
    // tmp遍历链表节点,newNode插入到合适位置的后继节点,
    // 所以tmp从head开始,遍历到tmp==head结束
    for (tmp = head; tmp->next != head; tmp = tmp->next)
    {
        // 当tmp的后继节点的数据大于新节点的数据时,tmp寻找到合适的位置插入
        if (tmp->next->data.num > newNode->data.num)
        {
            break;
        }
    }

    // 此时跳出循环,有两种结果：
    // 一是链表的节点数据都比newNode的数据小,tmp遍历到链表最后一个节点

    // 二是tmp遍历到合适的位置插入

    // 新节点的next指向tmp的next,防止后面的链表丢失
    newNode->next = tmp->next;
    // 新节点的prev指向tmp
    newNode->prev = tmp;
    // tmp的next指向newNode
    tmp->next = newNode;
    // 新节点的后继节点的prev指向新节点
    // 因为tmp->next已经改变,所以通过newNode->next索引到后继节点
    newNode->next->prev = newNode;

    // 返回有序插入之后的链表头节点
    return head;
}

/// @brief 遍历打印链表的数据
/// @param head 链表头节点
void display(P_node_t head)
{
    // 判断链表是否为空
    if (isListEmpty(head))
    {
        printf("链表为空.\n");
        return;
    }
    // tmp遍历链表每一个节点,所以tmp从有效节点开始,到tmp==head结束
    for (P_node_t tmp = head->next; tmp != head; tmp = tmp->next)
    {
        printf("[%d]:%s\n", tmp->data.num, tmp->data.name);
    }

    return;
}

/// @brief 查找匹配数据的节点
/// @param head 链表头节点
/// @param findData 要查找的数据
/// @return 查找成功返回查找到的节点地址,查找失败返回
P_node_t findListNode(P_node_t head, int findData)
{
    // 判读链表是否为空
    if (isListEmpty(head))
    {
        printf("链表为空.\n");
        return NULL;
    }
    P_node_t tmp = NULL, findNode = NULL;
    // tmp从链表有效节点开始遍历链表每一个节点
    for (tmp = head->next; tmp != head; tmp = tmp->next)
    {
        // 如果匹配数据,就存储tmp指向的节点地址
        if (tmp->data.num == findData)
        {
            findNode = tmp;
            break;
        }
    }
    // 此时findNode有两种情况:
    // 一是：未查找到匹配的节点,findNode为NULL
    // 二是：查找到匹配的节点,findNode不为NULL

    // 返回查找的结果
    return findNode;
}

/// @brief 修改链表节点数据
/// @param head 链表头节点
/// @param findData 要修改节点的数据
/// @return 成功返回修改成功的节点,失败返回NULL
P_node_t reviseListNode(P_node_t head, int findData)
{
    //查找要修改数据的节点
    P_node_t reviseNode = findListNode(head, findData);
    //判断是否查找到要修改数据的节点
    if (reviseNode == NULL)
    {
        printf("查找不到要修改数据的节点.\n");
        return NULL;
    }
    printf("请输入要修改的编号名字.\n");
    
    scanf("%d%s", &reviseNode->data.num, reviseNode->data.name);

    //返回修改完成的节点
    return reviseNode;
}

/// @brief 将节点从链表中剔除下来
/// @param head 链表头节点
/// @param delData 要剔除节点的数据
/// @return 剔除下来的节点
P_node_t delListNode(P_node_t head, int delData)
{
    P_node_t delNode = NULL;
    //在链表中寻找要剔除的节点
    delNode = findListNode(head, delData);
    //判断是否查找到要剔除的节点
    if (delNode == NULL)
    {
        printf("未查找到要删除的节点.\n");
        return NULL;
    }

    //要剔除节点的前驱节点的next指针指向要剔除节点的后继节点
    delNode->prev->next = delNode->next;
    //要剔除节点的后继节点的prev指针指向要剔除节点的前驱节点
    delNode->next->prev = delNode->prev;
    //将要剔除节点的next和prev指针指向自己,节点从链表中剔除下来
    delNode->next = delNode->prev = delNode;

    //返回剔除下来的节点
    return delNode;
}

/// @brief 插入排序链表
/// @param head 插入排序完成的链表头节点
void insertSort(P_node_t head)
{
    //判断链表是否为空
    if (isListEmpty(head))
    {
        //链表为空不需要排序
        printf("链表为空,无需排序.\n");
        return;
    }

    P_node_t outTmp = NULL, inTmp = NULL, insertNode = NULL;
    // 外循环outTmp遍历链表每一个节点进行插入排序
    for (outTmp = head->next; outTmp != head;)
    {
        //insertNode指向要插入的节点
        insertNode = outTmp;
        //内循环inTmp遍历要插入节点前的链表,寻找合适的位置来插入
        //插入需要前驱节点,所以inTmp从head开始,inTmp遍历到要插入节点的前驱节点结束
        for (inTmp = head; inTmp->next != insertNode; inTmp = inTmp->next)
        {
            //inTmp寻找到合适的位置插入,跳出循环
            if (inTmp->next->data.num > insertNode->data.num)
            {
                break;
            }
        }

        // 此时跳出循环,有两种情况:
        // 一是：要插入节点前的链表节点数据都比要插入节点数据小
        //此时要插入节点就在合适的位置上
        if (inTmp->next == insertNode)
        {   
            //更新outTmp往后遍历
            outTmp = outTmp->next;
            continue;
        }


        //二是：inTmp寻找到合适位置插入

        //更新outTmp往后遍历
        outTmp = outTmp->next;


        // 把insertNode节点从链表中剔除下来
        //insertNode的前驱节点的next指针指向insertNode的后继节点
        insertNode->prev->next = insertNode->next;
        //insertNode的后继节点的prev指针指向insertNode的前驱节点
        insertNode->next->prev = insertNode->prev;
        //insertNode的next和prev指针指向自己,节点从链表中剔除下来
        insertNode->next = insertNode->prev = insertNode;


        //insertNode插入到inTmp节点之后
        //insertNode的next指针指向inTmp的后继节点
        insertNode->next = inTmp->next;
        //insertNode的prev指向inTmp
        insertNode->prev = inTmp;
        //insertNode的前驱节点inTmp的next指针指向insertNode
        inTmp->next = insertNode;
        //insertNode的后继节点的prev指向insertNode
        insertNode->next->prev = insertNode;

    }

    return;
}

/// @brief 销毁链表,释放链表节点申请的堆内存空间
/// @param head 链表头节点
void destoryList(P_node_t head)
{
    P_node_t tmp = NULL,tmpPrev = NULL;
    //tmp遍历链表有效结点,tmpPrev销毁链表节点
    for (tmp= head->next;tmp!=head;)
    {
        //tmpPrev指向要销毁的节点
        tmpPrev = tmp;
        //tmp往后遍历
        tmp = tmp->next;
        //释放tmpPrev的堆内存空间
        free(tmpPrev);
    }
    //tmp指向头节点时跳出循环,此时头节点堆内存空间还未释放
    free(tmp);

    return;
}

/// @brief 查找链表的中间节点
/// @param head 链表头节点
/// @return 返回链表的中间节点
P_node_t findMiddleNode(P_node_t head)
{
    //判断链表是否为空
    if (isListEmpty(head))
    {
        printf("链表为空.\n");
        return NULL;
    }
    //快慢指针遍历链表
    //slow链表每次遍历一个节点
    //quick链表每次遍历两个节点
    P_node_t slow = head->next;
    P_node_t quick = head->next;

    //当quick到达链表末尾时,slow指针刚好到达链表中间节点
    //因为quick指针每次遍历是两个节点,所以判断quick和quick->next是否等于head
    while (quick != head && quick->next != head)
    {
        //slow指针每次遍历一个节点
        slow = slow->next;
        //quick指针每次遍历两个节点
        quick = quick->next->next;
    }
    //跳出循环时quick或者quick->next到达链表尾
    //此时slow指向链表中间节点

    //返回链表中间节点
    return slow;
}


int main(int argc, char const *argv[])
{
    P_node_t head = nodeInit(NULL);
    char menuOpt;
    int overFlag = 0, n, insertOpt, findData, reviseData, delData;
    data_t newData;
    P_node_t newNode = NULL, findNode = NULL, delNode = NULL, reviseNode = NULL,midNode = NULL;
    while (1)
    {
        printf("请选择要进行的操作.\n");
        printf("i.添加数据\ts.排序链表\td.显示链表\tf.查找数据\tg.修改数据\tx.删除数据\tz.查找链表中间节点\tt.退出\n");
        scanf("%c", &menuOpt);
        switch (menuOpt)
        {
        case 'i':
            printf("请输入要输入几个数.\n");
            scanf("%d", &n);
            if (n <= 0)
            {
                break;
            }
            printf("输入1.将数据头插到链表中\t2.将数据尾插到链表中\t3.将数据有序插入到链表中\n");
            scanf("%d", &insertOpt);
            for (int i = 0; i < n; i++)
            {
                // 获取数据
                newData = getData();
                // 初始化节点
                newNode = nodeInit(&newData);

                if (insertOpt == 1)
                {
                    // 将节点头插添加到链表中
                    head = addListHead(head, newNode);
                }
                else if (insertOpt == 2)
                {
                    // 将节点尾插插入到链表中
                    // 使用头插函数,将newNode插入到head的前继节点后即尾插
                    // 注意这里不能更新head,因为传进去是head->prev
                    // addListHead(head->prev, newNode);

                    head = addListTail(head, newNode);
                }
                else if (insertOpt == 3)
                {
                    // 将节点有序插入到链表中
                    head = addListOrder(head, newNode);
                }
            }

            break;
        case 'd':
            display(head);
            break;
        case 'z':
            midNode = findMiddleNode(head);
            if (midNode)
            {
                printf("查找成功,中间节点:地址:[%p]:[%d]:[%s]\n",midNode,midNode->data.num,midNode->data.name);
            }else
            {
                printf("查找失败.\n");
            }
            
            break;

        case 's':
            insertSort(head);
            break;

        case 'f':
            printf("请输入要查找的数据.\n");
            scanf("%d", &findData);
            findNode = findListNode(head, findData);
            if (findNode)
            {
                printf("查找成功,查找到的节点地址为:[%p]:[%d]:%s\n", findNode, findNode->data.num, findNode->data.name);
            }
            else
            {
                printf("未查找到查找的数据.\n");
            }

            break;

        case 'g':
            printf("请输入要修改节点的数据.\n");
            scanf("%d", &reviseData);
            reviseNode = reviseListNode(head, reviseData);
            if (reviseNode)
            {
                printf("修改成功,修改后的节点为:[%d]:%s\n", reviseNode->data.num, reviseNode->data.name);
            }
            else
            {
                printf("修改失败.\n");
            }

            break;

        case 'x':
            printf("请输入要删除节点的数据.\n");
            scanf("%d", &delData);
            delNode = delListNode(head, delData);
            if (delNode)
            {
                printf("删除成功.\n");
                free(delNode);
            }
            else
            {
                printf("剔除失败.\n");
            }

            break;

        case 't':
            overFlag = 1;
            break;
        }

        if (overFlag == 1)
        {
            break;
        }

        while (getchar() != '\n')
            ;
    }

    destoryList(head);

    return 0;
}

4. 适用场合

经过单链表、双链表的学习，可以总结链表的适用场合：

  • 适合用于节点数目不固定，动态变化较大的场合
  • 适合用于节点需要频繁插入、删除的场合
  • 适合用于对节点查找效率不十分敏感的场合

ZARD996
关注
  • 12
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值