【数据结构】有头循环双链表的创建销毁和增删改查

双链表： 节点包含两个指针跟一个数据存储，存放上一个和下一个节点的地址（双向链表），通过上一个节点的指针域去找下一个数据和上一个数据。

DSList.h中代码：

#pragma once

#include<assert.h>
//代码实现链表的操作函数

 //值类型 
typedef int DataType;

typedef struct  DSList {

    DataType data; // 值 
    struct  DSList *pNext; // 指向下一个结点 
    struct  DSList *pPre;//指向上一个结点

} DSList;

 //初始化 
void DSListInit(DSList **pFirst);

 //尾部插入 
void DSListPushBack(DSList* pFirst, DataType data);
//
// 头部插入 
void SListPushFront(DSList *pFirst, DataType data);
//
// 尾部删除 
void SListPopBack(DSList *pFirst);
//
// 头部删除 
void SListPopFront(DSList *pFirst);
//
// 给定结点插入，插入到结点前 
void SListInsert(DSList *pFirst, DSList *Pos, DataType data);
//
// 给定结点删除 
void SListErase(DSList *pFirst, DSList *pPos);
//
// 按值删除，只删遇到的第一个 
void SListRemove(DSList *pFirst, DataType data);
//
 //按值删除，删除所有的 
void SListRemoveAll(DSList *pFirst, DataType data);
//
// 销毁 
void SListDestroy(DSList *pFirst);

//清空链表头还在
void clear(DSList* pFirst);

 //按值查找，返回第一个找到的结点指针，如果没找到，返回 NULL 
DSList * SListFind(DSList *pFirst, DataType data);

//显示所有值
void DSListShow(DSList* pFirst);
//买一个空间
DSList *BuyNode(DataType data);

main.c中代码：

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

#include"DSList.h"


void DSListInit(DSList **pFirst)
{
    //assert(pFirst);
    int no_use = 0;
    *pFirst= BuyNode(no_use);
    (*pFirst)->pNext =*pFirst;
    (*pFirst)->pPre = *pFirst;
}

DSList *BuyNode(DataType data)
{
    DSList *New = (DSList*)calloc(sizeof(DSList),1);
    if (New!= NULL)
    {
        New->data = data;
        New->pNext = NULL;
        New->pPre = NULL;
    }

    return  New;

}

// 头部插入 
void SListPushFront(DSList *pFirst, DataType data)
{
    assert(pFirst);
    DSList *NewNode = BuyNode(data);
    DSList *pNext = pFirst->pNext;

    pFirst->pNext = NewNode;

    NewNode->pNext = pNext;
    NewNode->pPre = pFirst;

    pNext->pPre = NewNode;
}
//尾部插入 
void DSListPushBack(DSList* pFirst, DataType data)
{
    assert(pFirst);
    DSList *NewNode = BuyNode(data);
    assert(NewNode!=NULL);
    DSList *pLast= pFirst->pPre;


    pLast->pNext = NewNode;
    NewNode->pPre = pLast;
    NewNode->pNext = pFirst;
    pFirst->pPre = NewNode;
}

// 给定结点插入，插入到结点前 
void SListInsert(DSList *pFirst, DSList *Pos, DataType data)
{
    DSList *NewNode = BuyNode(data);
    DSList *pPrve = Pos->pPre;
    pPrve->pNext = NewNode;
    NewNode->pPre = pPrve;
    NewNode->pNext = Pos;
    Pos->pPre = NewNode;

}


// 尾部删除 
void SListPopBack(DSList *pFirst)
{
    assert(pFirst);

    SListErase(pFirst, pFirst->pPre);
}

// 头部删除 
void SListPopFront(DSList *pFirst)
{
    assert(pFirst);

    SListErase(pFirst, pFirst->pNext);

}

// 按值删除，只删遇到的第一个 
void SListRemove(DSList *pFirst, DataType data)
{
    assert(pFirst);

    DSList *ret= SListFind(pFirst, data);
    if (NULL != ret)
    {
        SListErase(pFirst, ret);
    }
    else
    {
        printf("没有这个数");
    }

}

//按值查找，返回第一个找到的结点指针，如果没找到，返回 NULL 
DSList *SListFind(DSList *pFirst, DataType data)
{
    assert(pFirst);

    DSList *pNext = pFirst->pNext;
    while (pNext != pFirst)
    {
        if (pNext->data ==data)
        {
            return pNext;
        }
        pNext = pNext->pNext;
    }


    return NULL;
}
//显示
void DSListShow(DSList* pFirst)
{
    assert(pFirst);
    DSList *pNext = pFirst->pNext;

    while (pNext != pFirst)
    {
        printf("%d->", pNext->data);
        pNext = pNext->pNext;
    }
    printf("\n");
}


// 给定结点删除 
void SListErase(DSList *pFirst, DSList *pPos)
{

    DSList *pNext = pPos->pNext;
    DSList *pPrve = pPos->pPre;

    pPrve->pNext=pNext;
    pNext->pPre = pPrve;

    free(pPos);
    pPos = NULL;

}
//按值删除，删除所有的 
void SListRemoveAll(DSList *pFirst, DataType data)
{
    DSList *pNext = pFirst->pNext;
    while (pNext != pFirst)
    {

        DSList *ret = SListFind(pNext, data);
        if (NULL != ret)
        {
            SListErase(pNext, ret);
        }

        pNext = pNext->pNext;
    }

}

//清空链表头还在
void clear(DSList* pFirst)
{
    DSList *pNode = pFirst->pNext;
    DSList *pNext;
    while (pNode != pFirst)
    {

        pNext = pNode->pNext;
        free(pNode);
        pNode = pNext;
    }
    pFirst->pNext = pFirst;
    pFirst->pPre = pFirst;

}

// 销毁 
void SListDestroy(DSList *pFirst)
{
    clear(pFirst);
    free(pFirst);
    pFirst = NULL;
    printf("销毁成功\n");
}

int main()
{

    DSList *my_son;
    DSListInit(&my_son);

    printf("尾部插入： ");
    DSListPushBack(my_son,1);
    DSListPushBack(my_son, 1);
    DSListPushBack(my_son, 1);
    DSListPushBack(my_son, 1);
    DSListPushBack(my_son, 2);
    DSListShow(my_son);

    printf("头部插入： ");
    SListPushFront(my_son, 2);
    DSListPushBack(my_son, 1);
    DSListShow(my_son);

    printf("头部删除： ");
    SListPopBack(my_son);
    DSListShow(my_son);

    printf("头部删除： ");
    SListPopFront(my_son);
    DSListShow(my_son);

    printf("按值删除，只删遇到的第一个1： ");
    SListRemove(my_son, 1);
    DSListShow(my_son);

    printf("按值删除，删遇到的所有的1： ");
    SListRemoveAll(my_son, 1);
    DSListShow(my_son);

    printf("查找1000： ");
    DSList *ret= SListFind(my_son,1000);
    if (NULL != ret)
    {
        printf("找到了\n");
    }
    else
    {
        printf("没找到\n");
    }
    SListDestroy(my_son);
    system("pause");
    return 0;
}

这里写图片描述

【数据结构】有头循环双链表的创建销毁和增删改查

猜你喜欢