循环链表与双向链表

1、循环链表

1.1 介绍

循环链表也是一种链式存储结构，它的特点是表中最后一个节点的指针域指向头节点。这样，从表中任何一个节点出发均可找到表中的其他所有节点。但要注意的是，这里循环链表遍历的条件不是p或者p->next是否为空，而是它们是否等于头指针（或者是是否等于开始遍历的节点指针）。图1是单循环链表的示意图。

图1 单循环链表

1.2 带尾指针的循环链表的合并

有时，在循环链表中设立尾指针而不设头指针，可以使某些操作简化，如将两个先线性表合并成一个表时，这个操作需要只需要改变两个指针的值即可，时间复杂度为O(1)，如下图2。

图2 带尾指针的单循环链表的合并

其具体操作过程如下代码：

A_head=A->next;
A->next=B->next->next;
B_head=B->next;
B->next=A_head;
free(B_head);A=B;

1.3 循环链表的应用——约瑟夫问题

约瑟夫斯问题（有时也称为约瑟夫斯置换），是一个出现在计算机科学和数学中的问题。在计算机编程的算法中，类似问题又称为约瑟夫环。这个问题是以弗拉维奥·约瑟夫斯命名的，它是1世纪的一名犹太历史学家。他在自己的日记中写道，他和他的40个战友被罗马军队包围在洞中。他们讨论是自杀还是被俘，最终决定自杀，并以抽签的方式决定谁杀掉谁。约瑟夫斯和另外一个人是最后两个留下的人。约瑟夫斯说服了那个人，他们将向罗马军队投降，不再自杀。约瑟夫斯把他的存活归因于运气或天意，他不知道是哪一个。
约瑟夫问题：有n个囚犯站成一个圆圈，准备处决。首先从一个人开始，越过k-2个人（因为第一个人已经被越过），并杀掉第k个人。接着，再越过k-1个人，并杀掉第k个人。这个过程沿着圆圈一直进行，直到最终只剩下一个人留下，这个人就可以继续活着。问题是，给定了n和k，一开始要站在什么地方才能避免被处决？(上面两段来自维基百科)

约瑟夫问题的典型应用就是猴子选大王：n只猴子要选大王，选举方法如下：所有猴子按 1，2 ……… n 编号并按照顺序围成一圈，从第 k 个猴子起，由1开始报数，报到m时，该猴子就跳出圈外，下一只猴子再次由1开始报数，如此循环，直到圈内剩下一只猴子时，这只猴子就是大王。输入数据：猴子总数n，起始报数的猴子编号k，出局数字m。输出数据：猴子的出队序列和猴子大王的编号。

循环链表可以说是原生支持这个场景，下面是代码来模拟该问题的解决，如下。

#include<stdio.h>
#include<stdlib.h>
#define OK 0
#define ERROR 1

typedef int ElemType;
typedef int Status;

//monkey total amount:n, start money number:k, the out nubmer:m
int n, k, m;

typedef struct LLNode
{
	ElemType data;
	struct LLNode *next;
}LLNode, *LoopLinkList;

//intitialize the loop link list L with data 1 to n
Status init_list(LoopLinkList &L, int n)
{
	//malloc space for head node
	L = (LoopLinkList)malloc(sizeof(LLNode));
	if (!L)
	{
		printf("The initialization of the list can not be completed!\n");
		return ERROR;
	}
	//the next of head points to itself
	L->next = L;
	//the data of head alse holds data too
	L->data = 1;
	LLNode *p = L;
	int i;
	for (i = 2;i <= n;i++)
	{
		LLNode *s = (LoopLinkList)malloc(sizeof(LLNode));
		if (!s)
		{
			printf("The initialization of the list can not be completed!\n");
			return ERROR;
		}
		s->data = i;
		s->next = p->next;
		p->next = s;
		p = p->next;
	}
	return OK;
}

Status list_delete(LLNode *s, ElemType &e)
{
	//delete the node s->next and return the its value with e
	LLNode *temp = s->next;
	s->next = s->next->next;
	e = temp->data;
	free(temp);
	return OK;
}

int main()
{
	
	printf("input the total amount of monkey:\n");
	scanf("%d", &n);
	printf("input the number of the start monkey:\n");
	scanf("%d", &k);
	printf("input the out amount of monkey:\n");
	scanf("%d", &m);

	LoopLinkList L;
	init_list(L, n);
	
	//find the one before k directly
	int i;
	LLNode *p = L;
	if (k == 1)
	{
		for (i = 1;i < n; i++)
		{
			p = p->next;
		}
	}else
	{
		for (i=1; i < k-1; i++)
		{
			p = p->next;
		}
	}

	while (n != 1)
	{
		//find the (m-1)th node
		for (i = 1;i <= m-1;p = p->next)
		{
			i++;
		}
		ElemType temp;
		if (p->next == L)
		{
			L = p;
		}

		list_delete(p,temp);
		printf("%d out!\n",temp);
		n--;
	}
	
	printf("The king is %d!!\n",L->data);
	return 0;
}

运行结果如下：

input the total amount of monkey:
5
input the number of the start monkey:
5
input the out amount of monkey:
2
1
2
3
4
5
1
-858993460 out!
-858993460 out!
-858993460 out!
-858993460 out!
The king is 2!!
请按任意键继续. . .

2、双向链表

2.1 介绍

由于单链表中只有一个指示直接后继的指针域，因此，从某个节点出发只能顺时针往后寻查其它节点。若要寻查直接前驱则需要从表头指针出发。也就是说，在单链表中，NextElem的时间复杂度为O(1)，而PriorElem的时间复杂度则为O(n)。为了克服单链表的这种缺点，我们可以利用双向链表（double linked list）。

在双向链表的节点中，有两个指针域，其一指向直接后继，另一个指向直接前驱，其C语言描述如下。

typedef struct DuLNode{
	ElemType data;
	struct DuLNode *prior;
	struct DuLNode *next;
}DuLNode,*DuLinkList;

2.2 双向循环链表

和单链的循环链表类似，双向链表也可以有循环链表，如图3中(c)所示，链表中有两个环，图3中(b)表示的是只有一个表头节点的空表。

图3 双向循环链表

在循环双向链表中，如果d为指向表中某一一节点的指针（即d为DuLinkList型变量），则会有：d->next->prior=d->prior->next=d。

2.3 双向链表的插入和删除

在双向链表中，ListLength、GetElem和LocateElem等操作仅需要涉及一个方向的指针，它们的算法描述和单链表的操作相同，但在插入和删除时由于要同时修改两个方向的指针，比单链表要稍显复杂。

图4 双向链表的插入和删除

2.4 代码

下面的代码中主要演示双向链表的插入和删除功能。

#include <stdio.h>
#include <cstdlib>

#define ERROR 0
#define OK 1

typedef int ElemType;
typedef int Status;


typedef struct DuLNode{
	ElemType data;
	struct DuLNode *prior;
	struct DuLNode *next;
}DuLNode,*DuLinkList;

DuLinkList GetInsertPosPtr_DuL(DuLinkList L, int i)
{
	DuLinkList p=L->next;

	//count一下链表中共有多少个元素
	int count;
	if (p == L)
	{
		count = 0;
	}else
	{
		for (count = 0; p != L; p = p->next)
		{
			count++;
		}
	}

	if (i > count+1 || i < 1)
		return NULL;
	else
	{
		p = L;
		int j;
		for (j = 0; j < i; j++)
		{
			p = p->next;
		}
		return p;
	}
}

Status ListInsert_DuL(DuLinkList &L, int i, ElemType e)
{
	//在带头节点的双向循环链表L中第i个位置之前插入元素e，i的合法值为1<=i<=表长+1
	DuLinkList p;
	//在L中确定插入位置指针p
	//当i等于表长加1时，p指向头节点;i大于表长加1时，p=NULL
	if (!(p = GetInsertPosPtr_DuL(L, i)))
	{
		return ERROR;
	}
	DuLinkList s;
	if (!(s = (DuLinkList)malloc(sizeof(DuLNode))))
	{
		return ERROR;
	}
	s->data = e;
	s->prior = p->prior;
	p->prior->next = s;
	s->next = p;
	p->prior = s;
	return OK;
}

DuLinkList GetElemPtr_DuL(DuLinkList L, int i)
{
	DuLinkList p = L->next;

	//count一下链表中共有多少个元素
	int count;
	if (p == L)
	{
		count = 0;
	}else
	{
		for (count = 0; p != L; p = p->next)
		{
			count++;
		}
	}

	if (i > count || i < 1)
		return NULL;
	else
	{
		p = L;
		int j;
		for (j = 0; j < i; j++)
		{
			p = p->next;
		}
		return p;
	}
}

Status ListDelete_DuL(DuLinkList &L, int i, ElemType &e)
{
	//删除带头节点的双向循环链表L的第i个元素，i的合法值为1<=i<=表长
	DuLinkList p;
	if (!(p = GetElemPtr_DuL(L, i)))
	{
		return ERROR;
	}
	e = p->data;
	p->prior->next = p->next;
	p->next->prior = p->prior;
	free(p);
	return OK;
}

int main()
{
	//定义一个循环链表，并将其初始化
	DuLinkList L;
	L = (DuLinkList)malloc(sizeof(DuLNode));
	L->next = L;
	L->prior = L;

	int i;
	for (i = 0; i < 5; i++)
	{
		ListInsert_DuL(L, i+1, i);
	}
	printf("链表中的元素如下：\n");
	DuLinkList p;
	i=0;
	for (p = L->next;p != L;p = p->next)
	{
		i++;
		printf("第%d个元素为:%d\n", i, p->data);
	}

	printf("输入要删除第几个元素:");
	int n;
	scanf("%d", &n);
	ElemType deleted;
	ListDelete_DuL(L, n, deleted);

	printf("第%d个元素的值为%d，已经将其从链表中删除。\n",n,deleted);

	printf("现在，链表中的元素如下：\n");
	i=0;
	for (p = L->next;p != L;p = p->next)
	{
		i++;
		printf("第%d个元素为:%d\n", i, p->data);
	}
	return 0;
}

程序的运行结果如下图5。

图5 程序的运行结果