74、循环链表

ᥬTff᭄

于 2024-08-18 21:03:39 发布

阅读量100

点赞数 1

文章标签：链表数据结构 c语言算法

本文链接：https://blog.csdn.net/qq_52137184/article/details/141305463

版权

单链表的局限

单链表可以用于表示任意的线性关系

有些线性关系是循环的，即没有队尾元素

单链表的改进

循环链表的定义

将单链表中最后一个数据元素的next指针指向第一个元素

循环链表的操作

循环链表拥有单链表的所有操作

创建链表

销毁链表

获取链表长度

清空链表

获取第ps个元素操作

插入元素到位置ps

删除位置ps处的元素

将单链表改写成循环链表

CircleList.h

#ifndef _CIRCLELIST_H_
#define _CIRCLELIST_H_

typedef void CircleList;
typedef struct _tag_CircleListNode CircleListNode;
struct _tag_CircleListNode
{
    CircleListNode* next;
};

CircleList* CircleList_Create();

void CircleList_Destroy(CircleList* list);

void CircleList_Clear(CircleList* list);

int CircleList_Length(CircleList* list);

int CircleList_Insert(CircleList* list, CircleListNode* node, int pos);

CircleListNode* CircleList_Get(CircleList* list, int pos);

CircleListNode* CircleList_Delete(CircleList* list, int pos);

CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node);

CircleListNode* CircleList_Reset(CircleList* list);

CircleListNode* CircleList_Current(CircleList* list);

CircleListNode* CircleList_Next(CircleList* list);

#endif

CircleList.c

#include <stdio.h>
#include <malloc.h>
#include "StaticList.h"

#define AVAILABLE -1//负一表示可用的

typedef struct _tag_StaticListNode
{
    unsigned int data;//存储节点的数据
    int next;//指向下一个节点的索引
} TStaticListNode;//静态链表中的一个节点

typedef struct _tag_StaticList
{
    int capacity;
    /* header作为TStaticListNode类型的一个实例，它包含了TStaticListNode结构体中定义的所有成员，即data和next */
    TStaticListNode header;
    /*
    在C99及之后的C语言标准中，允许在结构体的最后一个成员处定义一个没有指定大小的数组，这就是柔性数组。
    柔性数组并不占用结构体本身的大小（即sizeof(TStaticList)不包含node[]数组的大小），
    但它允许你在为一个包含柔性数组的结构体实例分配内存时，通过指定额外的字节数来为这个数组分配空间。
    */
    TStaticListNode node[];
} TStaticList;//整个静态链表

StaticList* StaticList_Create(int capacity) // O(n)
{
    TStaticList* ret = NULL;
    int i = 0;
    
    if( capacity >= 0 )
    {
        ret = (TStaticList*)malloc(sizeof(TStaticList) + sizeof(TStaticListNode) * (capacity + 1));
    }
    
    if( ret != NULL )
    {
        ret->capacity = capacity;
        ret->header.data = 0;
        ret->header.next = 0;
        
        for(i=1; i<=capacity; i++)
        {
            ret->node[i].next = AVAILABLE;//位置可用
        }
    }
    
    return ret;
}

void StaticList_Destroy(StaticList* list) // O(1)
{
    free(list);
}

void StaticList_Clear(StaticList* list) // O(n)
{
    TStaticList* sList = (TStaticList*)list;//因为用了数据封装，因此需要强制类型转换
    int i = 0;
    
    if( sList != NULL )
    {
        sList->header.data = 0;
        sList->header.next = 0;
        
        for(i=1; i<=sList->capacity; i++)
        {
            sList->node[i].next = AVAILABLE;//把所有位置标注为可用
        }
    }
}

int StaticList_Length(StaticList* list) // O(1)
{
    TStaticList* sList = (TStaticList*)list;
    int ret = -1;
    
    if( sList != NULL )
    {
        ret = sList->header.data;
    }
    
    return ret;
}

int StaticList_Capacity(StaticList* list) // O(1)
{
    TStaticList* sList = (TStaticList*)list;
    int ret = -1;
    
    if( sList != NULL )
    {
        ret = sList->capacity;
    }
    
    return ret;
}

int StaticList_Insert(StaticList* list, StaticListNode* node, int pos)  // O(n)
{
    TStaticList* sList = (TStaticList*)list;
    int ret = (sList != NULL);
    int current = 0;
    int index = 0;
    int i = 0;
    
    ret = ret && (sList->header.data + 1 <= sList->capacity);//单链表是否有位置？
    ret = ret && (pos >=0) && (node != NULL);
    
     /* 找可用位置 */
    if( ret )
    {
        for(i=1; i<=sList->capacity; i++)
        {
            if( sList->node[i].next == AVAILABLE )
            {
                index = i;//记下可用位置
                break;//跳出循环
            }
        }
        
        sList->node[index].data = (unsigned int)node;//将新元素先放到这个位置
        
        sList->node[0] = sList->header;
        
        for(i=0; (i<pos) && (sList->node[current].next != 0); i++)
        {
            current = sList->node[current].next;//移动pos次，
            //到的其实是pos-1的位置，正好在pos处插入元素，对吗？
        }
        
        sList->node[index].next = sList->node[current].next;//新元素的next = 当前元素的next
        sList->node[current].next = index;//当前元素的next就是新元素的位置
        
        sList->node[0].data++;
        
        sList->header = sList->node[0];//更新表头信息
    }
    
    return ret;
}

StaticListNode* StaticList_Get(StaticList* list, int pos)  // O(n)
{
    TStaticList* sList = (TStaticList*)list;
    StaticListNode* ret = NULL;//返回值变量
    int current = 0;//起始位置是头节点
    int object = 0;
    int i = 0;
    
    if( (sList != NULL) && (0 <= pos) && (pos < sList->header.data) )
    {
        sList->node[0] = sList->header;
        
        for(i=0; i<pos; i++)
        {
            current = sList->node[current].next;//pos-1
        }
        
        object = sList->node[current].next;//我们要获取的元素在静态链表里的下标
        
        ret = (StaticListNode*)(sList->node[object].data);
    }
    
    return ret;
}

StaticListNode* StaticList_Delete(StaticList* list, int pos) // O(n)
{
    TStaticList* sList = (TStaticList*)list;
    StaticListNode* ret = NULL;
    int current = 0;
    int object = 0;
    int i = 0;
    
    if( (sList != NULL) && (0 <= pos) && (pos < sList->header.data) )
    {
        sList->node[0] = sList->header;
        
        for(i=0; i<pos; i++)
        {
            current = sList->node[current].next;//当前元素下标，pos-1位置
        }
        
        object = sList->node[current].next;//要删除元素下标，pos位置的下标
        
        sList->node[current].next = sList->node[object].next;//pos-1元素链接要删除pos元素的下一个元素
        
        sList->node[0].data--;//表头--
        
        sList->header = sList->node[0];//更新表头信息
        
        sList->node[object].next = AVAILABLE;//表示为可用，next为-1即可用
        
        ret = (StaticListNode*)(sList->node[object].data);
    }
    
    return ret;
}

main.c

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

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

struct Value
{
    CircleListNode header;
    int v;
};

int main(int argc, char *argv[])
{
    int i = 0;
    CircleList* list = CircleList_Create();
    
    struct Value v1;
    struct Value v2;
    struct Value v3;
    struct Value v4;
    struct Value v5;
    struct Value v6;
    struct Value v7;
    struct Value v8;
    
    v1.v = 1;
    v2.v = 2;
    v3.v = 3;
    v4.v = 4;
    v5.v = 5;
    v6.v = 6;
    v7.v = 7;
    v8.v = 8;
    
    CircleList_Insert(list, (CircleListNode*)&v1, CircleList_Length(list));//第0个位置插入1
    CircleList_Insert(list, (CircleListNode*)&v2, CircleList_Length(list));//第1个位置插入2
    CircleList_Insert(list, (CircleListNode*)&v3, CircleList_Length(list));//第2个位置插入3
    CircleList_Insert(list, (CircleListNode*)&v4, CircleList_Length(list));//第3个位置插入4
    
    CircleList_Insert(list, (CircleListNode*)&v5, 5);//第5个位置插入5，循环链表
    CircleList_Delete(list, 0);//把第一个元素删掉，第一个元素的下标是0
    
    for(i=0; i<2*CircleList_Length(list); i++)
    {
        struct Value* pv = (struct Value*)CircleList_Get(list, i);
        
        printf("%d\n", pv->v);//5，2，3，4，5，2，3，4
    }
    
    printf("\n");
    
    while( CircleList_Length(list) > 0 )
    {
        struct Value* pv = (struct Value*)CircleList_Delete(list, 0);
        
        printf("%d\n", pv->v);
    }
    
    printf("\n");
    //求解约瑟夫问题
    CircleList_Insert(list, (CircleListNode*)&v1, CircleList_Length(list));
    CircleList_Insert(list, (CircleListNode*)&v2, CircleList_Length(list));
    CircleList_Insert(list, (CircleListNode*)&v3, CircleList_Length(list));
    CircleList_Insert(list, (CircleListNode*)&v4, CircleList_Length(list));
    CircleList_Insert(list, (CircleListNode*)&v5, CircleList_Length(list));
    CircleList_Insert(list, (CircleListNode*)&v6, CircleList_Length(list));
    CircleList_Insert(list, (CircleListNode*)&v7, CircleList_Length(list));
    CircleList_Insert(list, (CircleListNode*)&v8, CircleList_Length(list));
    
    for(i=0; i<CircleList_Length(list); i++)
    {
        struct Value* pv = (struct Value*)CircleList_Next(list);
        
        printf("%d\n", pv->v);//12345678
    }
    
    printf("\n");
    
    CircleList_Reset(list);//重置游标
    //循环出列
    while( CircleList_Length(list) > 0 )
    {
        struct Value* pv = NULL;
        
        for(i=1; i<3; i++)
        {
            CircleList_Next(list);
        }
        
        pv = (struct Value*)CircleList_Current(list);//取出
        
        printf("%d\n", pv->v);//36152847
        
        CircleList_DeleteNode(list, (CircleListNode*)pv);//把当前元素删除
    }
    
    CircleList_Destroy(list);
    
	return 0;
}

游标的定义

在循环链表中可以定义一个“当前”指针，这个指针通常称为游标，可以通过这个游标来遍历链表中的所有元素。

循环链表的新操作

获取当前游标指向的数据元素
- CircleListNode* CircleList_Current(CircleList*list);
将游标重置指向链表中的第一个数据元素
- CircleListNode* CircleList_Reset(CircleList*list);
将游标移动指向到链表中的下一个数据元素
- CircleListNode* CircleList_Next(CircleList*list);
直接指定删除链表中的某个数据元素
- CircleListNode* CircleList_DeleteNode(CircleList*list, CircleListNode* node);