<5> 一些关于链表的练习

1 . 给定两个已经排序好的表L1，L2，只用基本的表操作编写计算L1∩L2的过程。

std::vector<int> interse(LinkList *l1, LinkList *l2)
{
	std::vector<int> Temp;

	for (size_t i = 0; l1!=NULL; i++)
	{
		if (Find4(l2, l1->_age))
		{
			Temp.push_back(l1->_age);
		}

		l1 = l1->next;
	}

	return Temp;
}

原理就是：遍历l1的结点，然后找出l1的结点在l2中是否也存在，找出存在的数据就是两个链表的交集。

2 . 给定两个已经排序好的表L1，L2，只用基本的表操作编写计算L1∪L2的过程。

std::vector<int> All(LinkList *l1, LinkList *l2)
{
	std::vector<int> Temp;
	LinkList *l_temp = l1;

	while (l_temp !=NULL)
	{
		Temp.push_back(l_temp->_age);
		l_temp = l_temp->next;
	}

	while (l2!=NULL)
	{
		if (!Find4(l1, l2->_age))
		{
			Temp.push_back(l2->_age);
		}

		l2 = l2->next;
	}

	return Temp;
}

原理：拿到其中一个链表l1的所有数据域中的数据，然后查询l2链表中的数据在l1中不存在的，添加到容器中。其实也可以这样，直接查找其中一个链表l1的数据，在l2中不存在的，尾插到l2的链表末尾。我感觉第二种这种方式，才比较符合题目“只用基本的表操作”，第一方式使用了容器，有点投机取巧。

3 . 编写两个多项式相加的函数,不要毁坏数据。

DefinePolynomial *Merge(DefinePolynomial *l1, DefinePolynomial *l2)
{
	DefinePolynomial *head = NULL;
	DefinePolynomial *Temp = NULL;
	while (l1!=NULL || l2!=NULL)
	{
		if (l1 != NULL && l2 != NULL)
		{
			int compare = l1->exponential - l2->exponential;
			if (compare > 0)
			{
				Temp = l1;
				l1 = l1->next;
			}
			else if (compare<0)
			{
				Temp = l2;
				l2 = l2->next;
			}
			else if (compare == 0)
			{
				Temp = l1;
				Temp->coefficient = l1->coefficient + l2->coefficient;
				l1 = l1->next;
				l2 = l2->next;
			}
		}

		// HEAD
		if (head == NULL)
		{
		   head = Temp;
		}

		Temp = Temp->next;
	}
	
	Temp = NULL;
	return head;
}

原理：我是这么想的，两个链表：首先，谁的最大指数比较大，谁排第一个，然后依次递推。比如第一个链表的最大指数是4，第二个链表的最大指数是2（前提是多项式中的每一项的指数是递减的），那么应该让新的链表指向第一个链表的首元结点，接着让第一个链表的第二个结点和第二个链表的首元结点比较···用一条线将两个链表的每一个结点连接起来，指数相等的合并系数即可。

3 . 编号为1,2,3...n的人一词围成一圈，从第k个人开始报数（从1开始），数到m的人退出。接着下一个人又从1开始报数，数到m的人退出，以此类推。剩下的人的编号是多少？如：n=6,m=3,k=1 原始序列： 1  2  3  4  5  6 ； 从编号1开始报数 : 第一轮数完后的序列为：  1  2  4  5  ； 3、6出列——从编号1开始报数 : 第二轮数完后的序列为： 1  2  5 ；4出列——从编号5开始报数 : 第三轮数完后的序列为：   1  5 ； 2 出列——从5开始报数 : 第四轮数完后的序列为：   1  ；5 出列。所以，最后出列的编号为1。

/*
	约瑟夫环
*/

Game *CreateGame(unsigned int number)
{
	Game *head, *p1 = NULL, *p2 = NULL;

	p1 = (Game*)malloc(sizeof(Game));
	head = NULL;

	std::cin >> p1->index;
	for (size_t i = 1; i < number; i++)
	{
		if (head == NULL)
		{
			head = p1;
			p2 = p1;
		}
		else
		{
			p1 = (Game*)malloc(sizeof(Game));
			std::cin >> p1->index;
			p2->next = p1;
			p2 = p1;
		}
	}

	p2->next = head;
	p1 = NULL;
	free(p1);

	return head;
}

void StartGame(Game *L,int step)
{
	Game *temp = L;
	Game *location = NULL;

	while (!isEnd(L))
	{
		for (size_t i = 0; i < step; i++)
		{
			location = temp;
			temp = temp->next;
		}

		if (temp == L)
		{
			// 使尾结点指向首结点的下一个结点
			Game *End = EndNode(L);
			
			// 首结点后移
			L = temp->next;

			// 尾结点指向新的首结点
			End->next = L;

			temp = L;

			free(End);
		}
		else
		{
			// 删除次节点
			location->next = temp->next;
			temp = temp->next;
		}
		
		location = NULL;

		std::cout << std::endl;
		Print(L);
	}
}

Game *EndNode(Game *L)
{
	Game *temp = L;
	while (L->next != temp)
	{
		L = L->next;
	}

	return L;
}

bool isEnd(Game *L)
{
	return L->index == L->next->index;
}

void Print(Game *L)
{
	Game *Temp = L;
	while (L->next!=Temp)
	{
		std::cout << L->index << " ";
		L = L->next;
	}

	std::cout << L->index << std::endl;
}

原理：整个过程的核心其实就是一个“循环链表”来完成，这里循环结束的标志是“只剩下一个元素”，也就是当前结点的候机还是“当前结点”。比较麻烦的是：我在构造链表的时候，没有加上“头结点”，导致在处理首元结点的删除等操作时候，需要特殊处理。

4 . 逆序链表（不使用额外的链表）

LinkList *Reverselinked(LinkList *L)
{
	// 首结点的下一个结点是指向NULL；
	LinkList *Current = L;
	LinkList *Prev = NULL;

	while (Current->next !=NULL)
	{
		Prev = Current->next;
		Current->next = Prev->next;
		Prev->next = L;
		L = Prev;
	}

	return L;
}

原理：头插法即可。

未完待续···