线性表之循环链表、双向链表(三)--C语言实现

一、循环链表

循环链表（Circular linked list）是另一种形式的链式存储结构。它的特点是表中最后一个节点的指针域指向头结点，整个链表形成一个环。由此，从表中任一节点出发均可找到表中其他节点，如下所示为单链的循环链表：

单链的循环链表和单链表的本质一样，唯一的区别在于判断链表结束由判空改为了判断是否为头结点。下面给出具体的C语言代码实现：

头文件CList.h中给出循环链表结构体定义以及操作：

#ifndef CLIST_H_
#define CLIST_H_

typedef struct CNode
{
    int iData;
    struct CNode *pNext;
}CNode, *CList;

CNode* BuyNode(int val);
void InitList(CList plist);             //初始化链表
void HeadInsert(CList plist, int val);  //头插法
void TailInsert(CList plist, int val);  //尾插法
bool Delete(CList plist, int key);      //删除
void PrintList(CList plist);            //打印
int  GetLength(CList plist);            //获取链表长度
CNode *Search(CList plist, int key);    //查找
void Traverse(CList plist);             //倒置
void Destroy(CList plist);              //摧毁

#endif

源文件CList.c中给出循环链表的具体实现：

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

//申请节点
CNode* BuyNode(int val)
{
    CNode *pNew = (CNode*)malloc(sizeof(CNode));
    pNew->iData = val;
    pNew->pNext = nullptr;
    return pNew;
}

//初始化循环链表
void InitList(CList plist)          
{
    if (NULL == plist)
    {
        printf("The list isn't exist!!!\n");
        return;
    }
    plist->pNext = plist;
}

//头插法
void HeadInsert(CList plist, int val)
{
    if (NULL == plist)
    {
        printf("The list isn't exist!!!\n");
        return;
    }
    CNode *pNew = BuyNode(val);
    pNew->pNext = plist->pNext;
    plist->pNext = pNew;
}

//尾插法
void TailInsert(CList plist, int val)
{
    if (NULL == plist)
    {
        printf("The list isn't exist!!!\n");
        return;
    }
    CNode *pNew = BuyNode(val);
    CNode *pTemp = plist;
    for (; pTemp->pNext != plist; pTemp = pTemp->pNext)
    {
        NULL;
    }
    pNew->pNext = plist;
    pTemp->pNext = pNew;
}

//删除值为key的节点
bool Delete(CList plist, int key)   
{
    if (NULL == plist)
    {
        printf("The list isn't exist!!!\n");
        return false;
    }

    CNode *pPrior = plist;//指向前驱节点
    CNode *pCur = plist->pNext;

    for (; pCur != plist; pCur = pCur->pNext)   
    {
        if (pCur->iData == key)
        {
            pPrior->pNext = pCur->pNext;
            free(pCur);
            pCur = NULL;
            return true;
        }
        pPrior = pCur;
    }
    return false;
}

//打印链表
void PrintList(CList plist)
{
    if (NULL == plist)
    {
        printf("The list isn't exist!!!\n");
        return;
    }

    for (CNode *pTemp = plist->pNext; pTemp != plist; pTemp = pTemp->pNext)
    {
        printf("%5d", pTemp->iData);
    }
    printf("\n");
}

//获取链表长度
int  GetLength(CList plist)             
{
    if (NULL == plist)
    {
        printf("The list isn't exist!!!\n");
        return -1;
    }

    int iCount = 0;
    for (CNode *pTemp = plist->pNext; pTemp != plist; pTemp = pTemp->pNext)
    {
        ++iCount;
    }
    return iCount;
}

//查找
CNode *Search(CList plist, int key)     
{
    if (NULL == plist)
    {
        printf("The list isn't exist!!!\n");
        return NULL;
    }

    CNode *pTemp;
    for (pTemp = plist->pNext; pTemp != plist; pTemp = pTemp->pNext)
    {
        if (pTemp->iData == key)
        {
            break;
        }
    }
    return pTemp;
}

//倒置
void Traverse(CList plist)              
{
    if (NULL == plist)
    {
        printf("The list isn't exist!!!\n");
        return;
    }

    CNode *pTemp = plist->pNext;
    plist->pNext = plist;
    while (plist != pTemp)
    {
        CNode *pNext = pTemp->pNext;
        pTemp->pNext = plist->pNext;
        plist->pNext = pTemp;
        pTemp = pNext;
    }
}

//摧毁
void Destroy(CList plist)               
{
    if (NULL == plist)
    {
        printf("The list isn't exist!!!\n");
        return;
    }
    CNode *pTemp = plist->pNext;
    while (pTemp != plist)
    {
        plist->pNext = pTemp->pNext;
        free(pTemp);
        pTemp = plist->pNext;
    }
}

int main(void)
{
    CNode head;
    InitList(&head);
    for (int i = 0; i < 10; ++i)
    {
        TailInsert(&head, i);
    }
    PrintList(&head);
    printf("The list length is %d.\n", GetLength(&head));
    Traverse(&head);
    PrintList(&head);
    Delete(&head, 9);
    PrintList(&head);
    Destroy(&head);
    return 0;
}

二、双向链表

在以上讨论的链式存储结构的节点中只有一个指示其直接后继的指针域，若要寻找某节点的直接前驱，则需从表头指针出发遍历链表。为了克服单链链 这种单向性的缺点，可利用双向链表。
双向链表的节点中有两个指针域，其一指向直接后继，另一指向直接前驱。双向链表的结构如下图：

1.结构体定义

typedef struct DNode
{
    int iData;              //数据域
    struct DNode *pNext;    //后继指针
    struct DNode *pPrior;   //前驱指针
}DNode, *DList;

2.代码实现

 头文件DList.h中定义了结构体和双向链表的操作：

#ifndef DLIST_H_
#define DLIST_H_

typedef struct DNode
{
    int iData;              //数据域
    struct DNode *pNext;    //后继指针
    struct DNode *pPrior;   //前驱指针
}DNode, *DList;

DNode* BuyNode(int val);
void InitList(DList plist);             //初始化链表
void HeadInsert(DList plist, int val);  //头插法
void TailInsert(DList plist, int val);  //尾插法
bool Delete(DList plist, int key);      //删除
void PrintList(DList plist);            //打印
int  GetLength(DList plist);            //获取链表长度
DNode *Search(DList plist, int key);    //查找
void Traverse(DList plist);             //倒置
void Destroy(DList plist);              //摧毁
#endif

源文件DList.c中给出了以上操作的具体实现：

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


DNode* BuyNode(int val)
{
    DNode *pNew = (DNode*)malloc(sizeof(DNode));
    pNew->iData = val;
    pNew->pNext = NULL;
    pNew->pPrior = NULL;
    return pNew;
}

//初始化链表
void InitList(DList plist)
{
    if (NULL == plist)  //参数检查
    {
        printf("The list isn't exist.\n");
        return;
    }
    plist->pNext = NULL;
    plist->pPrior = NULL;
}

//头插法
void HeadInsert(DList plist, int val)
{
    if (NULL == plist)
    {
        printf("The list isn't exist.\n");
        return;
    }
    DNode *pNew = BuyNode(val);

    pNew->pPrior = plist;
    pNew->pNext = plist->pNext;
    if (NULL != plist->pNext)
    {
        plist->pNext->pPrior = pNew;
    }   
    plist->pNext = pNew;

}

//尾插法
void TailInsert(DList plist, int val)
{
    if (NULL == plist)
    {
        printf("The list isn't exist.\n");
        return;
    }
    DNode *pNew = BuyNode(val);
    DNode *pTail;
    for (pTail = plist; pTail->pNext != NULL; pTail = pTail->pNext)
    {
        NULL;   //空语句
    }
    pNew->pPrior = pTail;
    pTail->pNext = pNew;
}

//删除
bool Delete(DList plist, int key)
{
    if (NULL == plist)
    {
        printf("The list isn't exist.\n");
        return false;
    }

    DNode *pTemp = Search(plist, key);
    if (pTemp == plist)
    {
        printf("The list is empty.\n");
        return false;
    }
    else
    {
        DNode *pPrior = pTemp->pPrior;  //找到前驱节点
        pPrior->pNext = pTemp->pNext;   
        if (NULL != pTemp->pNext)
        {
            pTemp->pNext->pPrior = pPrior;
        }       
        return true;
    }
}

//打印
void PrintList(DList plist)
{
    for (DNode *pTemp = plist->pNext; pTemp != NULL; pTemp = pTemp->pNext)
    {
        printf("%5d", pTemp->iData);
    }
    printf("\n");
}

//获取链表长度
int  GetLength(DList plist)
{
    int iCount = 0;
    for (DNode *pTemp = plist->pNext; pTemp != NULL; pTemp = pTemp->pNext)
    {
        ++iCount;
    }
    return iCount;
}

//查找
DNode *Search(DList plist, int key)
{
    DNode *pTemp;
    for (pTemp = plist->pNext; pTemp != NULL; pTemp = pTemp->pNext)
    {
        if (pTemp->iData == key)
        {
            break;
        }
    }
    return pTemp;
}

//倒置
void Traverse(DList plist)
{
    DNode *pTemp = plist->pNext;
    plist->pNext = NULL;    //断开链表的头结点
    while (NULL != pTemp)
    {
        DNode *pNext = pTemp->pNext;
        pTemp->pNext = plist->pNext;
        pTemp->pPrior = plist;
        if (pTemp->pNext != NULL)
        {
            pTemp->pNext->pPrior = pTemp;
        }
        plist->pNext = pTemp;

        pTemp = pNext;
    }
}

//摧毁
void Destroy(DList plist)
{
    DNode *pTemp = plist->pNext;
    while (NULL != pTemp)
    {
        plist->pNext = pTemp->pNext;
        free(pTemp);
        pTemp = plist->pNext;
    }
}

int main(void)
{
    DNode head;
    InitList(&head);
    for (int i = 0; i < 10; ++i)
    {
        TailInsert(&head, i);
        PrintList(&head);
    }
    PrintList(&head);
    printf("The list length is %d.\n", GetLength(&head));
    Traverse(&head);
    PrintList(&head);
    for (int i = 0; i < 10; ++i)
    {
        Delete(&head, i);
        PrintList(&head);
    }

    Destroy(&head);
    return 0;
}

上面实现了循环链表和双向链表，大家可以把这两者进行结合一下写出双向循环链表。

我们这三篇博文中已经介绍完了线性表--顺序表（静态、动态）、单链表（普通单链表、循环链表和双向链表），这些很基础也很重要，不管是在学习中还是找工作时都考的很多，所以下一篇博文将针对线性表给出一些在面试和考试中常见的题目并编程实现。