数据结构（16）循环链表

来源：互联网发布：减肥淘宝排行榜编辑：程序博客网时间：2024/05/20 16:32

今天记录下循环链表，其实循环链表也就是将单链表中最后一个数据元素的next指针指向第一个元素。

这里有一个概念需要说明下：

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

如图

这里介绍静态链表的常用操作：

l 创建循环链表

l 销毁循环链表

l 清空�%@E�环链表

l 获取表长度

l 把node插入pos位置

l 获取pos位置的元素

l 删除pos位置的元素

l 删除表中与node相同的元素（删除第一个匹配成功的）

l 重置游标

l 返回游标所指向的结点

l 游标后移

代码总分为三个文件：

CircleList.h ：放置功能函数的声明，以及表的声明，表结点的定义

nbsp; CircleList.c ：放置功能函数的定义，以及表的定义

Main.c ：主函数，使用功能函数完成各种需求，不过一般用作测试

整体结构图为：

这里详细说下插入操作和删除操作：

插入操作：

如图

插入元素方法：

判断表和插入位置是否合法

由表头开始通过next域移动pos次后，当前元素的next域为要插入的位置

将新元素插入（和单链表插入方法相同）

表长度加1

判断是否为头插（就是头结点和首元素中间插入）

如果是头插的话，把尾结点的next域指向第一个元素（也就是头节点所指向的首元素）

如果之前表为空表，则游标指向插入的结点

删除操作：

如图

删除元素方法：

判断表和插入位置是否合法

由表头开始通过next域移动pos次后，当前元素的next指向的元素为要删除的元素

删除元素�%@C�和单链表删除元素相同）

表长度减1

判断是否删除的为首元素

如果删除的是首元素的话，把表尾结点的next域指向首元素

如果删除后表为空，则重置头结点的next域和游标

如果删除的结点正好游标也指向它，则游标后移

OK! 上代码：

CircleList.h

[cpp] view plaincopy
#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*&lbsp;CircleList_Get(CircleList* list, int pos);  
  
CircleListNode* CircleList_Delete(CircleList* list, int pos);  
  
CircleListNode* CircleList_DeleteNode(CircleLiqt* list, CircleListNode* node);  
  
CircleListNode* CircleList_Reset(CircleList* list);  
  
CircleListNode* CircleList_Current(CircleList* list);  
  
CircleListNode* CircleList_Next(CircleList* list);  
  
#endif  

CircleList.c

[cpp] view plaincopy
#include <stdio.h>  
#include <malloc.h>  
#include "CircleList.h"  
  
typedef struct _tag_CircleList  
{  
    CircleListNode header;  
    CircleListNode* slider;  
    int length;  
}TCircleList;  
  
CircleList* CircleList_Create()  
{  
    TCircleList* sList = (TCircleList*)malloc(sizeof(TCircleList));  
      
    if(NULL != sList)  
    {  
        sList->header.next = NULL;  
        sList->slider = NULL;  
        sList->length = 0;  
    }  
      
    return sList;  
}  
  
void CircleList_Destroy(CircleList* list)  
{  
    free(list);  
}  
  
void CircleList_Clear(CircleList* list)  
{  
    TCircleList* sList = (TCircleList*)list;  
      
    if(NULL != sList)  
    {  
        sList->header.next = NULL;  
        sList->slider = NULL;  
        sList->length = 0;  
    }  
}  
  
int CircleList_Length(CircleList* list)  
{  
    TCircleList* sList = (TCircleList*)list;  
      
    int ret = -1;  
      
    if(NULL != sList)  
    {  
        ret = sList->length;  
    }  
      
    return ret;  
}  
  
int CircleList_Insert(CircleList* list, CircleListNode* node, int pos)  
{  
    TCircleList* sList = (TCircleList*)list;  
      
    int ret = (NULL!=sList)&&(NULL!=node)&&(0<=pos);  
      
    int i = 0;  
      
    if(ret)  
    {  
        CircleListNode* current = (CircleListNode*)sList;  
          
        for(i=0; (i<pos)&&(current->next!=NULL); i++)  
        {  
            current = current->next;  
        }  
          
        node->next = current->next;  
        current->next = node;  
          
        if(0 == sList->length)  
        {  
            sList->slider = node;  
        }  
          
        sList->length++;  
          
        if(current == (CircleListNode*)sList)  
        {  
            CircleListNode* last = CircleList_Get(sList, sList->length-1);  
              
            last->next = current->next;  
        }  
    }  
      
    return ret;  
}  
  
CircleListNode* CircleList_Get(CircleList* list, int pos)  
{  
    TCircleList* sList = (TCircleList*)list;  
      
    CircleListNode* ret = NULL;  
      
    int i = 0;  
      
    if((NULL != sList)&&(0 < sList->length))  
    {  
        CircleListNode* current = (CircleListNode*)sList;  
          
        for(i=0; i<pos; i++)  
        {  
            current = current->next;   
        }  
          
        ret = current->next;  
    }  
      
    return ret;  
}  
  
CircleListNode* CircleList_Delete(CircleList* list, int pos)  
{  
    TCircleList* sList = (TCircleList*)list;  
      
    CircleListNode* ret = NULL;  
      
    int i = 0;  
      
    if((NULL != sList)&&(0 <= pos)&&(0 < sList->length))  
    {  
        CircleListNode* current = (CircleListNode*)sList;  
        CircleListNode* last = NULL;  
          
        for(i=0; i<pos; i++)  
        {  
            current = current->next;  
        }  
          
        ret = current->next;  
        current->next = ret->next;  
          
        sList->length--;  
          
        if(current == (CircleListNode*)sList)  
        {  
            last = (CircleListNode*)CircleList_Get(sList, sList->length-1);  
        }  
          
        if(NULL != last)  
        {  
            sList->header.next = ret->next;  
            last->next = ret->next;  
        }  
          
        if(ret == sList->slider)  
        {  
            sList->slider = ret->next;  
        }  
          
        if(0 == sList->length)  
        {  
            sList->slider = NULL;  
            sList->header.next = NULL;  
        }  
    }  
      
    return ret;  
}  
  
CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node)  
{  
    TCircleList* sList = (TCircleList*)list;  
      
    CircleListNode* ret = NULL;  
      
    int i = 0;  
      
    if((NULL != sList)&&(NULL != node))  
    {  
        CircleListNode* current = (CircleListNode*)sList;  
          
        for(i=0; i<sList->length; i++)  
        {  
            if(node == current->next)  
            {  
                ret = current->next;  
                break;  
            }  
              
            current = current->next;  
        }  
          
        if(NULL != ret)  
        {  
            CircleList_Delete(sList, i);  
        }  
    }  
      
    return ret;  
}  
  
CircleListNode* CircleList_Reset(CircleList* list)  
{  
    TCircleList* sList = (TCircleList*)list;  
      
    CircleListNode* ret = NULL;  
      
    if(NULL != sList)  
    {  
        sList->slider = sList->header.next;  
        ret = sList->slider;  
    }  
      
    return ret;  
}  
  
CircleListNode* CircleList_Current(CircleList* list)  
{  
    TCircleList* sList = (TCircleList*)list;  
      
    CircleListNode* ret = NULL;  
      
    if(NULL != sList)  
    {  
        ret = sList->slider;  
    }  
      
    return ret;  
}  
  
CircleListNode* CircleList_Next(CircleList* list)  
{  
    TCircleList* sList = (TCircleList*)list;  
      
    CircleListNode* ret = NULL;  
      
    if(NULL != sList)  
    {  
        ret = sList->slider;  
        sList->slider = ret->next;  
    }  
      
    return ret;  
}  

Main.c

[cpp] view plaincopy
#include <stdio.h>  
#include <stdlib.h>  
#include "CircleList.h"  
  
typedef struct _tag_Value  
{  
    CircleListNode header;  
    int v;  
}Value;  
  
int main(void)  
{  
    int i = 0;  
      
    CircleList* list = CircleList_Create();  
      
    Value v1,v2,v3,v4,v5,v6,v7,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));  
    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, 5);  
      
    CircleList_Delete(list, 0);  
      
    for(i=0; i<2*CircleList_Length(list); i++)  
    {  
        Value* p = (Value*)CircleList_Get(list, i);  
          
        printf("%d ", p->v);  
    }  
    printf("\n");  
      
    while(CircleList_Length(list) > 0)  
    {  
        Value* p = (Value*)CircleList_Delete(list, 0);  
          
        printf("%d ", p->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++)  
    {  
        Value* p = (Value*)CircleList_Next(list);  
          
        printf("%d ", p->v);  
    }  
    printf("\n");  
      
    CircleList_Reset(list);  
      
    while(CircleList_Length(list) > 0)  
    {  
        Value* pV = NULL;  
          
        for(i=1; i<3; i++)  
        {  
            CircleList_Next(list);  
        }  
          
        pV = (Value*)CircleList_Current(list);  
        printf("%d\n", pV->v);  
          
        CircleList_DeleteNode(list, (CircleListNode*)pV);  
    }  
      
    CircleList_Destroy(list);  
      
    return 0;  
}  

0 0