数据结构之循环链表

前面学习了链式结构链表，链式结构链表也有使用的局限性。比如说我们经常碰到的循环关系，

最经典的当然是约瑟夫问题了，那么我们怎么去解决约瑟夫问题呢？相信你看完本文章就会了，

好了言归正传，我们生活中经常会遇到循环问题，例如，一年的12个月，春夏秋冬交替，

这些循环关系怎么在我们的程序体现出来，少废话，上代码。

第四个例子，循环链表：

头文件

#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_Current(CircleList* list);

CircleListNode* CircleList_Next(CircleList* list);

CircleListNode* CircleList_Reset(CircleList* list);

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

#endif

我个人有点小小的强迫症，代码尽量要求简洁，所以没有注释，有什么不明白的可以留言。

实现文件

#include "CircleList.h"
#include <malloc.h>

typedef struct tag_CircleList
{
    CircleListNode header;
    CircleListNode* slider;
    int length;
}TCircleList;

CircleList* CircleList_Create()
{
    TCircleList* ret = NULL;
    
    ret = (TCircleList*)malloc(sizeof(TCircleList));
    if (ret)
    {
  		ret->length = 0;
  		ret->header.next = NULL;
  		ret->slider = NULL;
    }
    
    return (CircleList*)ret;
}

void CircleList_Destroy(CircleList* list)
{
    free(list);
}

void CircleList_Clear(CircleList* list)
{
    TCircleList* sList = (TCircleList*)list;
    
    if (sList != NULL)
    {
	    sList->length = 0;
	    sList->header.next = NULL;
	    sList->slider = NULL;
    }
}

int CircleList_Length(CircleList* list)
{
 	TCircleList* sList = (TCircleList*)list;
 	int ret = -1;
 	
 	if (sList != NULL)
    {
	    ret = sList->length;
	}	
 	
 	return ret;
}

int CircleList_Insert(CircleList* list, CircleListNode* node, int pos)
{
 	TCircleList* sList = (TCircleList*)list;
 	int ret = (sList != NULL) && (node != NULL);
 	ret = ret && (pos >= 0);
 	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 (sList->length == 0)
 		{
	  	    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 ((sList != NULL) && (pos >= 0))
 	{
  	    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 ((sList != NULL) && (pos >= 0) && (sList->length > 0))
 	{
  	    CircleListNode* current = (CircleListNode*)sList;
  	    CircleListNode* last = NULL;
  	    
  	    for (i = 0; i < pos; i++)
  	    {
		 	current = current->next;
		}
		
		if (current == (CircleListNode*)sList)
		{
		    last = (CircleListNode*)CircleList_Get(list, sList->length - 1);
		}
		
		ret = current->next;
		current->next = ret->next;
		
		sList->length--;
		
		if (last)
        {
	        sList->header.next= ret->next;
            last->next = ret->next;
        }
        
		if (sList->slider == ret)
		{
		     sList->slider = ret->next;
        }
		
		if (sList->length == 0)
		{
            sList->header.next = NULL;
            sList->slider = NULL;
        }
    }
 	
 	return ret;
}

CircleListNode* CircleList_Current(CircleList* list)
{
    TCircleList* sList = (TCircleList*)list;
 	CircleListNode* ret = NULL;
 	
 	if (sList != NULL)
 	{
        ret = sList->slider;
    }
 	
 	return ret;
}

CircleListNode* CircleList_Next(CircleList* list)
{
    TCircleList* sList = (TCircleList*)list;
 	CircleListNode* ret = NULL;
 	
 	if ((sList != NULL) && (sList->slider != NULL))
 	{
        ret = sList->slider;
        sList->slider = ret->next;
    }
 	
 	return ret;
}

CircleListNode* CircleList_Reset(CircleList* list)
{
    TCircleList* sList = (TCircleList*)list;
 	CircleListNode* ret = NULL;
 	
 	if (sList != NULL)
 	{
        sList->slider = sList->header.next;
        ret = sList->slider;
    }
 	
 	return ret;
}

CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node)
{
    TCircleList* sList = (TCircleList*)list;
 	CircleListNode* ret = NULL;
 	int i = 0;
 	
 	if (sList != NULL)
 	{
        CircleListNode* current = (CircleListNode*)sList;
        
        for (i = 0; i < sList->length; i++)
        {
		 	if (current->next == node)
		 	{
 			    ret = current->next;
 			    break;
 			}
	   	    current = current->next;
		}
		
		if (ret != NULL)
		{
		    CircleList_Delete(list, i);
		}
    }
			   
 	return ret;
}

在实现文件里面，是不是发现多几了函数呢？没错，那就是游标的操作，为什么要引入游标呢？

主要是游标操作大大的节省了对链表的操作时间。

测试文件

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

typedef struct tag_Value
{
    CircleListNode header;
    int v;
}Value;

int main(int argc, char *argv[])
{
 	CircleList* list = CircleList_Create();
 	
 	Value a,b,c,d,e,f,g,h;
 	
 	a.v = 1;
 	b.v = 2;
 	c.v = 3;
 	d.v = 4;
 	e.v = 5;
 	f.v = 6;
 	g.v = 7;
 	h.v = 8;
 	
 	int i = 0;
 	
 	CircleList_Insert(list, (CircleListNode*)&a, CircleList_Length(list));
 	CircleList_Insert(list, (CircleListNode*)&b, CircleList_Length(list));
 	CircleList_Insert(list, (CircleListNode*)&c, CircleList_Length(list));
 	CircleList_Insert(list, (CircleListNode*)&d, CircleList_Length(list));
 	
 	printf("length = %d\n", CircleList_Length(list));
 	
 	for (i = 0; i < 2 * CircleList_Length(list); i++)
 	{
	 	Value* p = (Value*)CircleList_Get(list, i);
	 	printf("%d\n", p->v);
	}
 	
 	CircleList_Clear(list);
 	
 	printf("length = %d\n", CircleList_Length(list));
 	
 	//下面我们来解决一个约瑟夫问题 
 	//8个人围成一个圈报数，每次报到3的退出，求出列顺序 
 	
 	CircleList_Insert(list, (CircleListNode*)&a, CircleList_Length(list));
 	CircleList_Insert(list, (CircleListNode*)&b, CircleList_Length(list));
 	CircleList_Insert(list, (CircleListNode*)&c, CircleList_Length(list));
 	CircleList_Insert(list, (CircleListNode*)&d, CircleList_Length(list));
 	CircleList_Insert(list, (CircleListNode*)&e, CircleList_Length(list));
 	CircleList_Insert(list, (CircleListNode*)&f, CircleList_Length(list));
 	CircleList_Insert(list, (CircleListNode*)&g, CircleList_Length(list));
 	CircleList_Insert(list, (CircleListNode*)&h, CircleList_Length(list));
 	
 	for (i = 0; i < CircleList_Length(list); i++)
 	{
	 	Value* p = (Value*)CircleList_Next(list);
	 	printf("%d\n", p->v);
	}
	printf("length = %d\n", CircleList_Length(list));
	
	while (CircleList_Length(list) > 0)
	{
	 	Value* p = NULL;
	 	
        for (i = 1; i < 3; i++)
        {
		 	CircleList_Next(list); 
        }
        
        p = (Value*)CircleList_Current(list);
        
		printf("%d\n", p->v);
        
        CircleList_DeleteNode(list, (CircleListNode*)p);
    } 
	
 	printf("length = %d\n", CircleList_Length(list));
  
    CircleList_Destroy(list);
    
    system("PAUSE");	
    return 0;
}

在测试文件里面，我已经把约瑟夫问题给解决了，是不是很简单呢？相信你在很多面试题中肯定也接触过，什么报数删除，什么猴子取桃，这些问题都可以用上面方法解决，好了循环链表演示完毕。