数据结构三：循环链表解决约瑟夫问题实现

                 解决链表实现 下面探讨一下单向循环链表的问题。   

             约瑟夫环是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。

               依据链表的实现方式实现了单循环链表：代码如下：

               头文件：

               

#ifndef _CIRCLELIST_H_
#define _CIRCLELIST_H_

typedef  void  CircleList;
typedef struct _tag_circlrlistnode
{
     struct _tag_circlrlistnode* next;
}ListNode;

CircleList* CircleList_Create();
void CircleList_Clear(CircleList* mlist);
void CircleList_Destroy(CircleList* mlist);
int CircleList_Length(CircleList* mlist);
int CircleList_Insert(CircleList* mlist,ListNode* node,int pos);
ListNode*  CircleList_Delete(CircleList* mlist,int pos);
ListNode*  CircleList_Get(CircleList* mlist,int pos);
//游标的处理
ListNode*  CircleList_SliderCurrent(CircleList* mlist);
ListNode* CircleList_SliderNext(CircleList* mlist);
ListNode* CircleList_DeleteNode(ListNode*  node);
ListNode*  CircleList_SliderReset(CircleList* mlist);

#endif<span style="font-family: Arial; background-color: rgb(255, 255, 255);">    </span>

    头文件的实现部分：

    

#include "stdlib.h"
#include "stdio.h"
#include "mycirclelist.h"

typedef struct _tag_TCirclelist
{
   ListNode header;
   ListNode* slider;
   int length;

}TCircleList;


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


}
void CircleList_Destroy(CircleList* mlist)
{
	 TCircleList* tcirclelist = (TCircleList*)mlist;
	 if(tcirclelist == NULL)
	 {
       return;
	 }
     tcirclelist->length = 0;
	 tcirclelist->header.next = NULL;
	 tcirclelist->slider = NULL;
	 free(tcirclelist);

}
int CircleList_Length(CircleList* mlist)
{
	 TCircleList* tcirclelist = (TCircleList*)mlist;
	 if(tcirclelist == NULL)
	 {
       return 0;
	 }
	 return tcirclelist->length;

}
int CircleList_Insert(CircleList* mlist,ListNode* node,int pos)
{
	int i = 0;
    ListNode* current = NULL;
	ListNode* last = NULL;
    //循环链表的插入与普通链表的插入不同之处就是头位置的插入
    TCircleList* tcirclelist = (TCircleList*)mlist;
	if(tcirclelist == NULL || pos < 0 || node == NULL)
	{
       return -1;
	}
	current = &(tcirclelist->header);
    for(i = 0 ; i < pos; i++)
	{
		current = current->next;
	}
    
    //普通插入节点
	node->next = current->next;
	current->next = node;
    //添加第一个元素 设置游标的位置
    if( CircleList_Length(tcirclelist) == 0)
	{
		tcirclelist->slider = node;
	}
	//长度加1
	tcirclelist->length++;


	if(current == &(tcirclelist->header))
	{
       last =  CircleList_Get(tcirclelist,CircleList_Length(tcirclelist)-1);
	}
  
	//获得最后一个节点的位置
	if(last != NULL)
	{
		last->next = current->next;
	}

	return 0;
}
ListNode*  CircleList_Delete(CircleList* mlist,int pos)
{
	int i = 0;
    ListNode* current = NULL;
	ListNode* ret = NULL;
	ListNode* last = NULL;
    //循环链表的插入与普通链表的插入不同之处就是头位置的插入
    TCircleList* tcirclelist = (TCircleList*)mlist;
	if(tcirclelist == NULL || pos < 0 )
	{
       return NULL;
	}
	current = &(tcirclelist->header);
    for(i = 0 ; i < pos; i++)
	{
		current = current->next;
	}

  
	//删除头结点的处理
	if(current == &(tcirclelist->header))
	{
	    last =  CircleList_Get(tcirclelist,CircleList_Length(tcirclelist)-1);
	}
	  //删除节点
	ret = current->next;
	current->next = ret->next;
	tcirclelist->length--;
	
    	//获得最后一个节点的位置
	if(last != NULL)
	{
		last->next = current->next;
	}

	//如果删除的元素是游标指向的元素
	if(tcirclelist->slider == ret)
	{
		tcirclelist->slider = ret->next;
	}

    //如果链表只有一个节点  进行容错处理
	if( CircleList_Length(tcirclelist) == 0 )
	{
		tcirclelist->header.next = NULL;
		tcirclelist->slider = NULL;
	}

	return ret;
    
}
ListNode*  CircleList_Get(CircleList* mlist,int pos)
{
	 int i = 0;
     ListNode* current = NULL;
	 TCircleList* tcirclelist = (TCircleList*)mlist;
	 if(tcirclelist == NULL || pos < 0 ||  pos > CircleList_Length(tcirclelist))
	 {
         return NULL;
	 }
	 current = &(tcirclelist->header);
	 for(i = 0 ; i < pos;i++)
	 {
		 current = current->next;
	 }
	 return current->next;
}
//游标的处理
ListNode*  CircleList_SliderCurrent(CircleList* mlist)
{
	TCircleList* tcirclelist = (TCircleList*)mlist;
	if(tcirclelist == NULL)
	{
      return NULL;
	}
	return tcirclelist->slider;
}

ListNode* CircleList_SliderNext(CircleList* mlist)
{
	//游标下移  注意游标默认值是第一个元素节点 返回的是下移之前的位置
	ListNode*  ret;
	TCircleList* tcirclelist = (TCircleList*)mlist;
	if(tcirclelist == NULL)
	{
      return NULL;
	}
	ret = tcirclelist->slider ; 
	tcirclelist->slider = tcirclelist->slider->next;
	return ret;
}

ListNode* CircleList_DeleteNode(CircleList* mlist,ListNode*  node)
{
    TCircleList* sList = (TCircleList*)mlist;
	ListNode* ret = NULL;
	int i = 0;

	if( sList != NULL )
	{
		ListNode* current = (ListNode*)sList;
		
		//查找node在循环链表中的位置i
		for(i=0; 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;

}
ListNode*  CircleList_SliderReset(CircleList* mlist)
{
	
	TCircleList* tcirclelist = (TCircleList*)mlist;
	if(tcirclelist == NULL)
	{
      return NULL;
	}
	tcirclelist->slider = tcirclelist->header.next;
	return tcirclelist->slider;
}

     模仿约瑟夫环的场景实现：

     

#include "stdlib.h"
#include "stdio.h"
#include "mycirclelist.h"

typedef struct _tag_Teacher
{
   ListNode node;
   int age;
   char* name;
}Teacher;



void testdemo1()
{
	CircleList* mcirclelist;
	int i = 0;
    Teacher t1,t2,t3,t4,t5,t6,t7,t8;
	t1.age = 11;
	t2.age = 22;
	t3.age = 33;
	t4.age = 44;
	t5.age = 55;
	t6.age = 66;
	t7.age = 77;
	t8.age = 88;
	t1.name = "shao11";
	t2.name = "shao22";
	t3.name = "shao33";
	t4.name = "shao44";
	t5.name = "shao55";
	t6.name = "shao66";
	t7.name = "shao77";
	t8.name = "shao88";

    mcirclelist =  CircleList_Create();
	CircleList_Insert(mcirclelist,(ListNode*)&t1,0);
	CircleList_Insert(mcirclelist,(ListNode*)&t2,1);
	CircleList_Insert(mcirclelist,(ListNode*)&t3,2);
	CircleList_Insert(mcirclelist,(ListNode*)&t4,0);
	CircleList_Insert(mcirclelist,(ListNode*)&t5,4);
	CircleList_Insert(mcirclelist,(ListNode*)&t6,0);
	CircleList_Insert(mcirclelist,(ListNode*)&t7,0);
	CircleList_Insert(mcirclelist,(ListNode*)&t8,0);
    for(i = 0; i < CircleList_Length(mcirclelist); i++)
	{
        Teacher* mnode = (Teacher*)CircleList_Get(mcirclelist,i);
		printf("node age:%d;node name:%s\n",mnode->age,mnode->name);
	}
  
    //游标重置
    CircleList_SliderReset(mcirclelist);
	while( CircleList_Length(mcirclelist) > 0)
	{
       Teacher* mnode = NULL;
       for(i = 1; i < 3;i++)
	   {
          mnode = (Teacher*)CircleList_SliderNext(mcirclelist);
	   }
	   //删除节点  当前游标的位置
       mnode = CircleList_SliderCurrent(mcirclelist);
	   printf("delete node age:%d;node name:%s\n",mnode->age,mnode->name);
	   CircleList_DeleteNode(mcirclelist,mnode);

	}

	CircleList_Destroy(mcirclelist);

}
void main()
{
	testdemo1();
	printf("邵忠棋");
	system("pause");
}

     delete node的意思就是出局的人。。。。

     

     让你能够更加体会出数据结构的魅力， Just Like! Just Do IT!!