数据结构链表2（常考题型2）

相交链表：

. - 力扣（LeetCode）

题目：

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

图示两个链表在节点 c1 开始相交：

解题思路：

特殊情况：

        若两个链表没有相交部分，当两个链表走到NULL就结束。

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) 
{
	struct ListNode* cur1 = headA;
	struct ListNode* tmp1 = headA;
	struct ListNode* cur2 = headB;
	struct ListNode* tmp2 = headB;
	int num1 = 0, num2 = 0;
	while (cur1)
	{
		num1++;
		cur1 = cur1->next;
	}
	while (cur2)
	{
		num2++;
		cur2 = cur2->next;
	}
	int num = abs(num1-num2);//计算num1-num2的绝对值
	while (num--)
	{
		if (num1 > num2)
		{
			tmp1 = tmp1->next;
		}
		else
		{
			tmp2 = tmp2->next;
		}
	}
	while (tmp1 && tmp2)
	{
		if (tmp1 == tmp2)//正常情况
		{
			return tmp1;
		}
		tmp1 = tmp1->next;
		tmp2 = tmp2->next;
	}
	return NULL;//特殊情况
}

环形链表I：

. - 力扣（LeetCode）

题目：

给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ，则返回 true 。 否则，返回 false 。

解题思路：

        该题涉及到一些数学问题：类似相遇问题。

想要解决此类问题，先来看这一个问题：

三角形能否追上正方向形？

也就是，如果一个速度是1，另一个速度时2时，无论如何都能追上。

这个问题理解了，这个题才可以解。

当一个速度是1，另一个速度是2的两个指针，入环之后，之间肯定有距离，而且是整数，如果一直在环里走，肯定能追上！

特殊情况：

1、如果只有一个元素，有环时，也适用。

2、如果只有一个元素，无环时，或只是奇数个元素的链表无环时，当fast->next == NULL时结束。

3、当有偶数个元素的链表无环时，当fast指针自身等于NULL时结束。

代码如下：
 

	struct ListNode* fast = head;
	struct ListNode* slow = head;
	while (fast)
	{
		if (fast->next == NULL)
		{
			return false;
		}
		fast = fast->next->next;
		slow = slow->next;
		if (fast == slow)
		{
			return true;
		}
	}
	return false;

 环形链表II：

. - 力扣（LeetCode）

题目：

给定一个链表的头节点  head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

解题思路：

        做该题首先得把环形链表I看懂：

刚刚我们说了一个数学问题，这回把这个问题扩展一下，也就是加入直赛道。

二者都是从直道的起点开始走。

满足什么条件的时候相遇？如何找到他们入环点？

这道题也就迎刃而解了。

也就是只要找到相遇点，然后让两个指针，一个从起点出发，一个从相遇点出发每次走一步最终会相遇的！！

代码如下：

struct ListNode* detectCycle(struct ListNode* head) 
{
	 	struct ListNode* fast = head;
		struct ListNode* slow = head;
		struct ListNode* cur1 = head;
		struct ListNode* cur2 = NULL;
		while (fast)
		{
			if (fast->next == NULL)
			{
				return NULL;
			}
			fast = fast->next->next;
			slow = slow->next;
			if (fast == slow)
			{
				cur2 = fast;
				while (1)
				{
					if (cur1 == cur2)
					{
						return cur2;
					}
					cur1 = cur1->next;
					cur2 = cur2->next;
				}
			}
		}
		return NULL;
}  

随机链表的复制：

. - 力扣（LeetCode）

 题目：

给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。

构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。

例如，如果原链表中有 X 和 Y 两个节点，其中 X.random --> Y 。那么在复制链表中对应的两个节点 x 和 y ，同样有 x.random --> y 。

返回复制链表的头节点。

用一个由 n 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 [val, random_index] 表示：

• val：一个表示 Node.val 的整数。
• random_index：随机指针指向的节点索引（范围从 0 到 n-1）；如果不指向任何节点，则为  null 。

你的代码 只 接受原链表的头节点 head 作为传入参数。

解题思路：

先来探究一个简单的。

该题的难点在于random的指向该如何确定！

可以采用插入新链表，最后再尾插的形式解决。

这样做的目的就是新malloc的空间的random可以通过旧的链表的random的next找到！

代码如下：
 

struct Node* copyRandomList(struct Node* head) 
{
    struct Node* cur1 = head;
	struct Node* cur2 = head;
	struct Node* cur3 = head;
	struct Node* newhead = NULL;
	struct Node* tmp = NULL;
    //复制链表
	while (cur1)
	{
		struct Node* copy = (struct Node*)malloc(sizeof(struct Node));
		copy->next = cur1->next;
		cur1->next = copy;
		copy->val = cur1->val;
		cur1 = copy->next;
	}
//复制random
    while (cur2)
	{
		
		if (cur2->random != NULL)
		{
			cur2->next->random = cur2->random->next;
		}
		else
		{
			cur2->next->random = NULL;
		}
		cur2 = cur2->next->next;
	}
	//进行尾插
	while (cur3)
	{
		if (newhead == NULL)
		{
			newhead = tmp = cur3->next;
		}
		else
		{
			tmp->next = cur3->next;
			tmp = tmp->next;
		}
		cur3 = cur3->next->next;
	}
    if(tmp != NULL)
    {
	tmp->next = NULL;
    }
	return newhead;
}