C 循环链表

循环链表的定义：将单链表中最后一个数据元素的next指针指向第一个元素

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

1）普通插入元素（和单链表是一样的）

2）尾插法（和单链表是一样的，单链表的写法支持尾插法；

因：辅助指针向后跳length次，指向最后面那个元素）

CircleList_Insert(list, (CircleListNode*)&v1, CircleList_Length(list));

1）头插法（要进行头插法，需要求出尾结点，和单链表不一样的地方，保证是循环链表）

第一次插入元素时，让游标指向0号结点

CircleList_Insert(list, (CircleListNode*)&v1, 0);

4)第一次插入元素

循环链表插入综合场景分析图

循环链表删除结点分析

1、删除普通结点

2、删除头结点（删除0号位置处元素），需要求出尾结点

优点：功能强了。

循环链表只是在单链表的基础上做了一个加强

循环链表可以完全取代单链表的使用

循环链表的Next和Current操作可以高效的遍历链表中的所有元素

#ifndef _CIRCLELIST_H_

#define _CIRCLELIST_H_

/*

typedef struct _tag_CircleListNode CircleListNode;

struct _tag_CircleListNode

{

    CircleListNode* next;

};

*/

typedef void T;

typedef struct _tag_CircleListNode

{

    struct _tag_CircleListNode * next;

}CircleListNode;

T* CircleList_Create();

void List_Destroy(T* list);

void CircleList_Clear(T* list);

int CircleList_Length(T* list);

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

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

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

//add

//根据结点的值 进行数据的删除

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

CircleListNode* CircleList_Reset(T* list);

CircleListNode* CircleList_Current(T* list);

//游标指向2号位置

//把2号位置返回出来,同时让游标下移到3号位置

CircleListNode* CircleList_Next(T* list);

#endif

#include <stdio.h>

#include <malloc.h>

#include "CircleList.h"

typedef struct _tag_CircleList//循环链表结构体（头结点，游标，长度）

{

    CircleListNode header;//头结点

    CircleListNode* slider;//游标

    int length;

} TCircleList;

T* CircleList_Create() // O(1)初始化链表结构体

{

    TCircleList* ret = (TCircleList*)malloc(sizeof(TCircleList));

    if (ret == NULL)

    {

        return NULL;

    }

    ret->length = ;

    ret->header.next = NULL;

    ret->slider = NULL;

    return ret;

}

void CircleList_Destroy(T* list) // O(1)

{

    if (list == NULL)

    {

        return ;

    }

    free(list);

}

void CircleList_Clear(T* list) // O(1)

{

    TCircleList* sList = (TCircleList*)list;

    if (sList == NULL)

    {

        return ;

    }

    sList->length = ;

    sList->header.next = NULL;

    sList->slider = NULL;

}

int CircleList_Length(T* list) // O(1)

{

    TCircleList* sList = (TCircleList*)list;

    int ret = -;

    if (list == NULL)

    {

        return ret;

    }

    ret = sList->length;

    return ret;

}

int CircleList_Insert(T* list, CircleListNode* node, int pos) // O(n)

{

    int ret = , i=;

    TCircleList* sList = (TCircleList*)list;

    if (list == NULL || node== NULL || pos<)

    {

        return -;

    }

    CircleListNode* current = (CircleListNode*)sList;//头结点

    for(i=; (i<pos) && (current->next != NULL); i++)

    {

        current = current->next;

    }

    //current->next 0号节点的地址

    node->next = current->next; //

    current->next = node; //2

    //若第一次插入节点

    if( sList->length ==  )//这里游标一直指向第0号位置

    {

        sList->slider = node;

    }

    sList->length++;

    //若头插法 current仍然指向头部

    //（原因是：跳0步，没有跳走）

    if( current == (CircleListNode*)sList )

    {

        //获取最后一个元素

        CircleListNode* last = CircleList_Get(sList, sList->length - );

        last->next = current->next; //

    }

    return ret;

}

CircleListNode* CircleList_Get(T* list, int pos) // O(n)

{

    TCircleList* sList = (TCircleList*)list;

    CircleListNode* ret = NULL;

    int i = ;

    if (list==NULL || pos<)

    {

        return NULL;

    }

    //if( (sList != NULL) && (pos >= 0) && (sList->length > 0) )

    {

        CircleListNode* current = (CircleListNode*)sList;

        for(i=; i<pos; i++)

        {

            current = current->next;

        }

        ret = current->next;

    }

    return ret;

}

CircleListNode* CircleList_Delete(T* list, int pos) // O(n)

{

    TCircleList* sList = (TCircleList*)list;

    CircleListNode* ret = NULL;

    int i = ;

    if( (sList != NULL) && (pos >= ) && (sList->length > ) )

    {

        CircleListNode* current = (CircleListNode*)sList;

        CircleListNode* last = NULL;

        for(i=; i<pos; i++)

        {

            current = current->next;

        }

        //若删除第一个元素（头结点）

        if( current == (CircleListNode*)sList )

        {

            last = (CircleListNode*)CircleList_Get(sList, sList->length - );

        }

        //求要删除的元素

        ret = current->next;

        current->next = ret->next;

        sList->length--;

        //判断链表是否为空

        if( last != NULL )

        {

            sList->header.next = ret->next;

            last->next = ret->next;

        }

        //若删除的元素为游标所指的元素

        if( sList->slider == ret )

        {

            sList->slider = ret->next;

        }

        //若删除元素后，链表长度为0

        if( sList->length ==  )

        {

            sList->header.next = NULL;

            sList->slider = NULL;

        }

    }

    return ret;

}

CircleListNode* CircleList_DeleteNode(T* list, CircleListNode* node) // O(n)

{

    TCircleList* sList = (TCircleList*)list;

    CircleListNode* ret = NULL;

    int i = ;

    if( sList != NULL )

    {

        CircleListNode* current = (CircleListNode*)sList;

        //查找node在循环链表中的位置i

        for(i=; i<sList->length; i++)

        {

            if( current->next == node )

            {

                ret = current->next;

                break;

            }

            current = current->next;

        }

        //如果ret找到，根据i去删除

        if( ret != NULL )

        {

            CircleList_Delete(sList, i); //根据结点的值 求出结点的位置 ,根据位置删除元素

        }

    }

    return ret;

}

CircleListNode* CircleList_Reset(T* list) // O(1)

{

    TCircleList* sList = (TCircleList*)list;

    CircleListNode* ret = NULL;

    if( sList != NULL )

    {

        sList->slider = sList->header.next;

        ret = sList->slider;

    }

    return ret;

}

CircleListNode* CircleList_Current(T* list) // O(1)

{

    TCircleList* sList = (TCircleList*)list;

    CircleListNode* ret = NULL;

    if( sList != NULL )

    {

        ret = sList->slider;

    }

    return ret;

}

//把当前位置返回，并且游标下移

//把当前游标所指的位置的元素返回出去

//游标下移

CircleListNode* CircleList_Next(T* list) // O(1)

{

    TCircleList* sList = (TCircleList*)list;

    CircleListNode* ret = NULL;

    if( (sList != NULL) && (sList->slider != NULL) )

    {

        ret = sList->slider;

        sList->slider = ret->next;

    }

    return ret;

}

#include <stdio.h>

#include <stdlib.h>

#include "CircleList.h"

struct Value

{

    CircleListNode circlenode;

    int v;

};

int main11()

{

    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;

    int i = ;

    v1.v = ;

    v2.v = ;

    v3.v = ;

    v4.v = ;

    v5.v = ;

    v6.v = ;

    v7.v = ;

    v8.v = ;

    CircleList_Insert(list, (CircleListNode*)&v1, );

    CircleList_Insert(list, (CircleListNode*)&v2, );

    CircleList_Insert(list, (CircleListNode*)&v3, );

    CircleList_Insert(list, (CircleListNode*)&v4, );

    for(i=; i<*CircleList_Length(list); i++) //怎么样证明是循环链表

    {

        struct Value* pv = (struct Value*)CircleList_Get(list, i);

        printf("%d\n", pv->v);

    }

    while( CircleList_Length(list) >  )

    {

        CircleList_Delete(list, );

    }

    printf("\n");

    CircleList_Destroy(list);

    system("pause");

    return ;

}

#include <stdio.h>

#include <stdlib.h>

#include "CircleList.h"

struct Value

{

    CircleListNode header;

    int v;

};

void  main()

{

    int i = ;

    CircleList* list = CircleList_Create();

    struct Value v1, v2, v3, v4, v5, v6, v7, v8;

    v1.v = ;    v2.v = ;    v3.v = ;    v4.v = ;

    v5.v = ;    v6.v = ;    v7.v = ;    v8.v = ;

    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=; i<CircleList_Length(list); i++)

    {

        //获取游标所指元素,然后游标下移

        struct Value* pv = (struct Value*)CircleList_Next(list);

        printf("%d ", pv->v);

    }

    printf("\n");

    //重置游标

    CircleList_Reset(list);

    while( CircleList_Length(list) >  )

    {

        struct Value* pv = NULL;

        for(i=; i<; i++)

        {

            CircleList_Next(list);

        }

        pv = (struct Value*)CircleList_Current(list);

        printf("%d ", pv->v);

        CircleList_DeleteNode(list, (CircleListNode*)pv); //根据结点的值,进行结点元素的删除

    }

    CircleList_Destroy(list);

    system("pause");

    return ;

}

巴特西

C 循环链表

循环链表删除结点分析

最新文章

热门文章