一步一步学数据结构之1--1（循环链表）

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

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

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

        如图

 

    

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

                         l 创建循环链表

                         l 销毁循环链表

                         l 清空循环链表

                         l 获取表长度

                         l 把node插入pos位置

                         l 获取pos位置的元素

                         l 删除pos位置的元素

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

                         l 重置游标

                         l 返回游标所指向的结点

                         l 游标后移

             

        代码总分为三个文件：

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

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

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

       整体结构图为：

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

 

              插入操作：

                     如图

                    

                     插入元素方法：

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

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

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

                            表长度加1

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

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

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

  

            删除操作：

                   如图

                   

                   删除元素方法：

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

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

                          删除元素（和单链表删除元素相同）

                          表长度减1

                          判断是否删除的为首元素

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

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

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

   

OK! 上代码：

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 "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

#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;
}