双向链表的增-删-查-逆序

头文件DList.h

#pragma once

#include
#include
#include

typedef int DataType;

typedef struct DListNode
{
    DataType _data;
    struct DListNode* _next;
    struct DListNode* _prev;


}DListNode,*Dlist;

void InitDlist(DListNode* pHead);//初始化
Dlist BuyDlistNode(DataType x);//插入数据
void DlistPrint(Dlist pHead);//打印链表

void DlistPuchBack(Dlist pHead, DataType x);//尾插
void DlistPopBack(Dlist pHead);//尾删

void DlistPuchFront(Dlist pHead, DataType x);//头插
void DlistPopFront(Dlist pHead);//头删

void DlistInset(Dlist pos, DataType x);//任意位置插入
void DlistErase(Dlist pos);//任意位置删除

Dlist DlistFind(Dlist pHead, DataType x);//查找链表中的数
void DlistReverseOne(Dlist pHead);//链表的逆置
void DlistReverseTwo(Dlist pHead);//链表的逆置

DList.c源文件

#define  _CRT_SECURE_NO_WARNINGS 1

#include"DList.h"



void InitDlist(DListNode* pHead)
{
    assert(pHead);
    pHead->_prev = pHead;
    pHead->_next = pHead;

}
Dlist BuyDlistNode(DataType x)
{
    Dlist node = (Dlist)malloc(sizeof(DListNode));
    assert(node);
    node->_data = x;  
    node->_next = NULL;
    node->_prev = NULL;
    return node;

}
void DlistPrint(Dlist pHead)//打印链表
{
    Dlist cur = pHead->_next;
    while (cur != pHead)
    {
        printf("%d->", cur->_data);
        cur = cur->_next;
    }
    printf("\n");
}
void DlistPuchBack(Dlist pHead, DataType x)//尾插
{
    assert(pHead);
    Dlist prev = NULL, tail = NULL, newNode = NULL;
    tail = pHead->_prev;
    newNode = BuyDlistNode(x);

    tail->_next = newNode;
    newNode->_prev = tail;

    pHead->_prev = newNode;
    newNode->_next = pHead;

}
void DlistPopBack(Dlist pHead)//尾删
{
    assert(pHead);
    //if (pHead->_next != pHead)
    //{
    //  Dlist tail = pHead->_prev;
    //  Dlist tPrev = tail->_prev;
    //  free(tail);
    //  pHead->_prev = tPrev;
    //  tPrev->_next = pHead;
    //  tail = NULL;
    //
    //}
    if (pHead->_next != pHead)
    {
        DlistErase(pHead->_next);
    }

}
void DlistPuchFront(Dlist pHead, DataType x)//头插
{
    assert(pHead);
    Dlist first = pHead->_next;
    Dlist newNode = BuyDlistNode(x);
    pHead->_next = newNode;
    newNode->_prev = pHead;

    newNode->_next = first;
    first->_prev = newNode;
}
void DlistPopFront(Dlist pHead)//头删
{
    assert(pHead);
    if (pHead->_next != pHead)
    {
        Dlist first = pHead->_next;
        Dlist fNext = first->_next;
        free(first);
        pHead->_next = fNext;
        fNext->_prev = pHead;
        first = NULL;
    }

}
Dlist DlistFind(Dlist pHead, DataType x)//查找链表中的数
{
    assert(pHead);
    Dlist cur = pHead->_next;
    while (pHead != cur->_next)
    {
        if (x == cur->_data)
        {
            return cur;
        }
        cur = cur->_next;
    }
    return NULL;

}
void DlistInset(Dlist pos, DataType x)//任意位置插入
{
    assert(pos);
    Dlist posPrev = pos->_prev;
    Dlist newNode = BuyDlistNode(x);
    posPrev->_next = newNode;
    newNode->_prev = posPrev;

    newNode->_next = pos;
    pos->_prev = newNode;

}
void DlistErase(Dlist pos)//任意位置删除
{
    assert(pos);
    if (pos->_next != pos)
    {
        Dlist prev = pos->_prev;
        Dlist next = pos->_next;
        free(pos);
        prev->_next = next;
        next->_prev = prev;
        pos = NULL;
    }

}
void DlistReverseOne(Dlist pHead)//链表的逆置
{
    assert(pHead);
    Dlist first = pHead->_prev;//定义两个指针一个从前，一个在后向中间走交换数据
    Dlist last = pHead->_next;
    DataType tmp = 0;
    while (first != last && first->_next != last)
    {
        tmp = first->_data;
        first->_data = last->_data;
        last->_data = tmp;
        first = first->_next;
        last = last->_prev;
    }

}
void DlistReverseTwo(Dlist pHead)//链表的逆置
{
    assert(pHead);
    Dlist cur = pHead;
    Dlist tmp = NULL;
    do
    {
        tmp = cur->_prev;//直接交换节点
        cur->_prev = cur->_next;
        cur->_next = tmp;
        cur = cur->_next;

    } while (cur != pHead);

}

测试文件test.c

#include"DList.h"



Test1()
{
    DListNode list;
    Dlist ret = NULL;
    InitDlist(&list);

    DlistPuchBack(&list, 1);//尾插
    DlistPuchBack(&list, 2);
    DlistPuchBack(&list, 3);
    DlistPuchBack(&list, 4);
    DlistPuchBack(&list, 5);

    DlistPrint(&list);
    DlistReverseTwo(&list);//测试逆序
    DlistPrint(&list);

    ret = DlistFind(&list, 1);
    DlistInset(ret, 5);//测试随意插入
    DlistPrint(&list);
    DlistErase(ret);//随意删除
    DlistPrint(&list);
    DlistPopBack(&list);//尾删
    DlistPopBack(&list);
    DlistPopBack(&list);
    DlistPopBack(&list);
    DlistPopBack(&list);
    DlistPrint(&list);

    DlistPuchFront(&list,1);//头插
    DlistPuchFront(&list, 2);
    DlistPuchFront(&list, 3);
    DlistPuchFront(&list, 4);
    DlistPrint(&list);


    DlistPopFront(&list);//头删
    DlistPopFront(&list);
    DlistPopFront(&list);
    DlistPopFront(&list);
    DlistPopFront(&list);
    DlistPrint(&list);


}
int main()
{
    Test1();
    system("pause");
    return 0;
}