数据结构线性表C语言实现双向链表模板

C语言双向链表模板

#include <stdio.h>
#include <stdlib.h>
/************************************************
 * C语言双向链表模板
 * 
 * 1.InitDLink(ElemType data) 初始化双向链表:动态分
 * 配一个头结点，让该结点的前驱和后驱都指向自己,并为头
 * 结点数据域赋值.
 * 
 * 2.DisplayDLink(DLink *head) 输出数据
 * 
 * 3.InsertDLink(DLink *head, ElemType data) 添加
 * 数据:保存头结点的上一个结点,动态分配一个新结点,让它
 * 的后驱指向头结点,前驱指向头结点的前驱,并让头结点的
 * 前驱的后驱指向新结点,最后让头结点的前驱指向新结点,并
 * 为新结点数据域赋值.
 * 
 * 4.DeleteDLink(DLink *head, ElemType deleteData)
 * 删除数据:把需要删除的结点从双向链表中删除,前驱的后驱
 * 指向后驱,后驱的前驱指向前驱,并释放该结点内存.
 * 
 * 5.UpdateDLink(DLink *head, ElemType deleteData,
 *  ElemType updateData) 更新数据:找到需要更新数据的
 * 结点对数据域进行更新.
 * 
 * 6.SelectDLink(DLink *head, ElemType data) 查找
 * 数据:找到需要的数据返回TRUE,没有找到输出没有找到并
 * 返回FALSE.
 * 
 * 7.DestoryDLink(DLink *head) 销毁双向链表:释放所有
 * 动态分配的内存.
 * 
 * 8.OrderDLink(DLink *head) 数据排序:复制一份双向链
 * 表,对复制的链表进行冒泡排序操作后,进行输出和销毁操
 * 作.
 * 
 * 作者:西瓜小羽毛
 * 日期:2020/7/22 
 ************************************************/
#define TRUE 1
#define FALSE 0
typedef bool BOOL;
typedef int ElemType;
typedef struct DLink
{
    DLink *prior;
    ElemType data;
    DLink *next;
} DLink;
/* 初始化双向链表 */
DLink *InitDLink(ElemType data)
{
    DLink *head = (DLink *)malloc(sizeof(DLink));
    head->data = data;
    head->next = head;
    head->prior = head;
    return head;
}
/* 输出数据 */
void DisplayDLink(DLink *head)
{
    if (head == NULL)
    {
        printf("双向链表未初始化\n");
        return;
    }
    DLink *pNode = head;
    while (pNode->next != head)
    {
        printf("%d ", pNode->data);
        pNode = pNode->next;
    }
    printf("%d \n", pNode->data);
}
/* 添加数据 */
void InsertDLink(DLink *head, ElemType data)
{
    if (head == NULL)
    {
        printf("链表未初始化\n");
        return;
    }
    DLink *node = (DLink *)malloc(sizeof(DLink));
    node->next = head;
    node->prior = head->prior;
    node->data = data;
    head->prior->next = node;
    head->prior = node;
}
/* 删除数据 */
void DeleteDLink(DLink *head, ElemType deleteData)
{
    if (head == NULL)
    {
        printf("链表未初始化\n");
        return;
    }
    DLink *pNode = head;
    if (deleteData == pNode->data)
    {
        DLink *qNode = pNode->next;
        pNode->data = qNode->data;
        pNode->next = qNode->next;
        pNode->next->prior = pNode;
        free(qNode);
        return;
    }
    pNode = pNode->next;
    while (pNode != head)
    {
        if (pNode->data == deleteData)
        {
            pNode->prior->next = pNode->next;
            pNode->next->prior = pNode->prior;
            free(pNode);
            break;
        }
        pNode = pNode->next;
    }
    if (pNode == head)
    {
        printf("没有找到需要删除的数据\n");
        return;
    }
    else
    {
        return;
    }
}
/* 更新数据 */
void UpdateDLink(DLink *head, ElemType deleteData, ElemType updateData)
{
    if (head == NULL)
    {
        printf("链表未初始化\n");
        return;
    }
    DLink *pNode = head;
    if (pNode->data == deleteData)
    {
        pNode->data = updateData;
        return;
    }
    pNode = pNode->next;
    while (pNode != head)
    {
        if (pNode->data == deleteData)
        {
            pNode->data = updateData;
            break;
        }
        pNode = pNode->next;
    }
    if (pNode == head)
    {
        printf("没有找到需要的数据\n");
        return;
    }
    else
    {
        return;
    }
}
/* 查询数据 */
ElemType SelectDLink(DLink *head, ElemType data)
{
    if (head == NULL)
    {
        printf("链表未初始化\n");
        return 0;
    }
    DLink *pNode = head;
    if (pNode->data == data)
    {
        return data;
    }
    pNode = pNode->next;
    while (pNode != head)
    {
        if (pNode->data == data)
        {
            break;
        }
        pNode = pNode->next;
    }
    if (pNode == head)
    {
        printf("没有找到需要的数据\n");
        return 0;
    }
    else
    {
        return data;
    }
}
/* 销毁双向链表 */
void DestoryDLink(DLink *head)
{
    if (head == NULL)
    {
        printf("链表未初始化\n");
        return;
    }
    DLink *node = head->prior;
    DLink *pNode = head;
    DLink *qNode = head;
    while (pNode != node)
    {
        qNode = pNode;
        pNode = pNode->next;
        free(qNode);
    }
    free(node);
}
/* 数据排序 */
void OrderDLink(DLink *head)
{
    if (head == NULL)
    {
        printf("链表未初始化\n");
        return;
    }
    /* 复制双向链表 */
    DLink *tHead = (DLink *)malloc(sizeof(DLink));
    tHead->data = head->data;
    DLink *pNode = tHead;
    DLink *qNode = head;
    DLink *nNode = NULL;
    while (qNode->next != head)
    {
        nNode = (DLink *)malloc(sizeof(DLink));
        nNode->data = qNode->next->data;
        pNode->next = nNode;
        nNode->prior = pNode;
        pNode = pNode->next;
        qNode = qNode->next;
        nNode = nNode->next;
    }
    pNode->next = tHead;
    tHead->prior = pNode;
    pNode = tHead;
    qNode = tHead;
    while (pNode->next != tHead)
    {
        qNode = tHead;
        while (qNode->next != tHead)
        {
            if (qNode->data > qNode->next->data)
            {
                ElemType tData = qNode->next->data;
                qNode->next->data = qNode->data;
                qNode->data = tData;
            }
            qNode = qNode->next;
        }
        pNode = pNode->next;
    }
    printf("排序后:");
    DisplayDLink(tHead);
    DestoryDLink(tHead);
}

测试代码

#include "DoubleLinkList.h"
int main()
{
    /* 双向链表测试代码 */
    DLink *head = InitDLink(30);
    InsertDLink(head, 10);
    InsertDLink(head, 16);
    InsertDLink(head, 30);
    InsertDLink(head, 20);
    DisplayDLink(head);
    UpdateDLink(head, 10, 22);
    printf("更新10:");
    DisplayDLink(head);
    DeleteDLink(head, 20);
    printf("删除20:");
    DisplayDLink(head);
    printf("查找数据:%d\n", SelectDLink(head, 5));
    OrderDLink(head);
}

运行结果

30 10 16 30 20
更新10:30 22 16 30 20
删除20:30 22 16 30
没有找到需要的数据
查找数据:0
排序后:16 22 30 30