链表的经典问题

链表的经典问题

如何判断两个单链表是否相交，如果相交，找出交点（两个链表都不存在环）

如果两个单链表相交，那应该呈“Y”字形，也就是从交点以后的部分是两个链表的公共节点。

所以，判断是否相交只要看两个链表的最后一个节点是否为同一个即可。

那么如何找到交点呢？设两个单链表的长度分别为L1、L2，（假设L1>L2），则(L1-L2)的值就是交汇之前两个链表的长度差；

因此，只有让更长的链表先走L1-L2步，然后两个链表开始一起走，如果某次走到一个相同的节点，该节点即为交点。

C代码实现：

typedef struct _ListNode {
int data;
struct _ListNode *next;
} ListNode;

static int GetListLength(ListNode *T)
{
int n;

for(n=0; T; n++) {
T = T->next;
}

return n;
}

static ListNode* FindFirstCommonNode(ListNode *T1, ListNode *T2)
{
int i;
int n1 = GetListLength(T1);
int n2 = GetListLength(T2);

// T1 always own longer list
if (n1 < n2) {
return FindFirstCommonNode(T2, T1);
}

for (i=0; i<n1-n2; i++) {
T1 = T1->next;
}

while (T1 && T1 != T2) {
T1 = T1->next;
T2 = T2->next;
}
return T1;
}

该问题还有一种思路，就是将其中一个链表首尾相连，然后检测另外一个链表是否有环，如果存在环，则两个链表相交。

判断一个链表是否有环，并找到环的入口点

如果一个单链表有环，那应该呈“6”字形。

设置两个指针(fast, slow)，初始值都指向头节点，slow每次前进一步，fast每次前进二步，如果链表存在环，则fast必定先进入环，而slow后进入环，两个指针必定 相遇：如果链表是呈"O"字形，则slow刚好遍历完一次的时候，与fast相遇；如果呈“6”字形，则更早相遇。

当fast若与slow相遇时，slow还没有遍历完链表，而fast已经在环内循环了n圈(1<=n)。假设slow走了s步，则 fast走了2s步（fast步数还等于s 加上在环上多转的n圈），设环长为r，则：

2s = s + nr，简化为 s= nr

s = x + y，x为链表起点到环入口点的距离，y是slow在环内走过的距离；

可以得到 x = y - s = y - nr，从链表头、相遇点分别设一个指针(p1, p2)，每次各走一步，当p1走过距离x时到达入口点，而p2走过的距离为y-nr，y是相遇点与入口点的距离，因此y也走到了入口点，也就是说p1、p2在环入口点相遇了。

C代码实现：

static ListNode* FindLoopPort(ListNode *Head)
{
ListNode *slow = Head;
ListNode *fast = Head;

// 找到相遇点
while ( fast && fast->next ) {
slow = slow->next;
fast = fast->next->next;
if ( slow == fast ) break;
}

if (fast == NULL || fast->next == NULL)
return NULL;

// 找到环入口点
slow = Head;
while (slow != fast)
{
slow = slow->next;
fast = fast->next;
}

return slow;
}

求一个单链表（无环）的中间节点

设置两个指针(fast, slow)，初始值都指向头节点，slow每次前进一步，fast每次前进二步，当fast走到末尾时，slow刚好指向中间节点。

假如链表长度为N，如何返回链表的倒数第K个结点

思路：用两个指针，指针P1先走K-1步，然后指针P2才开始走，当指针P1遍历完链表时，P2还剩K个结点没有遍历。

实现如下：

ListNode *FindLastKNode(ListNode *Head, int K)
{
if (NULL == Head)
return NULL;

ListNode *T1 = Head;
ListNode *T2 = Head;

while (T1 && --K)
T1 = T1->next;

if (K)     // here, K must be 0
return NULL;

while (T1->next) {
T1 = T1->next;
T2 = T2->next;
}

return T2;
}

在O(1)时间删除链表结点

在链表中删除一个结点，最常规的做法是遍历链表，找到要删除的结点后再删除，这种做法的时间复杂度是O(n)；
换一种思路，根据待删除结点A，可以知道其下一个结点是B=A->next，将结点B值拷贝给A，然后删除B即可。
这种方法需要考虑一种特殊情况，A如果是尾结点，则B不存在，此时仍需要遍历链表一次。

C代码实现：

void DeleteNode(ListNode* Head, ListNode *pDel)
{
if (NULL == pDel || NULL == Head)
return;

ListNode *p = Head;
if (NULL == pDel->next) {     // pDel is the last node
while (pDel != p->next)
p = p->next;
p->next = NULL;
free(pDel);

} else {
p = pDel->next;
pDel->next = p->next;
pDel->data = p->data;
free(p);
}
}

如何逆序输出一个单链表

方法一：从头到尾遍历链表，每经过一个结点的时候，把该结点放到一个栈中；当遍历完整个链表后，再从栈顶开始输出结点的值。
该方法需要维护一个额外的栈，实现起来比较麻烦。我们注意到递归本质上就是一个栈结构，所以，也可以用递归来实现反向输出链表。

方法二：也就是说，每访问到一个结点的时候，先递归输出它后面的结点，再输出该结点自身。

C代码实现：

void ReversePrint(ListNode *Head)
{
if (Head) {

if (Head->next) {
ReversePrint(Head->next);
}

printf("%d ", Head->data);
}
}

如何反转一个单链表

利用辅助指针就地修改节点的next域，代码如下：

static ListNode *ReverseList(ListNode *Head)
{
ListNode *pNode = Head;
ListNode *pNext = NULL;
ListNode *pPrev = NULL;

while (pNode) {
pNext = pNode->next;
if (NULL == pNext)     // meet the end
Head = pNode;
pNode->next = pPrev;
pPrev = pNode;
pNode = pNext;
}

return Head;
}

递归 的实现方法：

static void ReverseList2(ListNode** Head)
{
ListNode *p = *Head;

if (!p) return;

ListNode* rest = p->next;

if (!rest) return;

ReverseList2(&rest);
rest->next = p;
p->next = NULL;
}

复杂链表的复制

假设有一个复杂链表，它除了有一个next指针外，还有一个other指针，指向链表中的任一结点或者NULL，

typedef struct _ListNode {
int data;
struct _ListNode *next;
struct _ListNode *other;
} ListNode;

如下图，是一个含义5个节点的该类型的复杂链表，实线表示next指针，虚线表示other指针，NULL指针未标出。



最简单的方法是，先复制所有节点，并用next指针链接起来，然后假设原始链表的某节点N的other指针指向节点S，由于S的位置可能在N的前面，也可能在N的后面，所以要定位N的位置需要从原始链表的头节点开始找，直到确认节点S在链表中的位置为s；然后在复制链表上节点N的other指针也要指向距离链表头的第s个节点。这种方法的时间复杂度是O(n2)。

上面这种方法的主要缺点在于无法快速定位N节点的other所指向的S节点的位置，

下面将介绍一种时间复杂度是O(n)的方法，首先把复制的节点串到原节点后面，如下图：



然后设置复制节点的other指针（例如 A'->other = A->other->next），如下图



最后，把偶数顺序的节点和奇数节点的指针分开。

// 逐个节点复制，并串到原节点后面
static void CloneNodes(ListNode *Head)
{
ListNode *p = Head;

while (p) {

ListNode *pCloned = malloc(sizeof(ListNode));

pCloned->data = p->data;
pCloned->next = p->next;
pCloned->other = NULL;

p->next = pCloned;
p = pCloned->next;
}
}

// 设置新节点的other指针
static void ConnectNodes(ListNode *Head)
{
ListNode *pCloned;
ListNode *p = Head;

while(p){

pCloned = p->next;

if (p->other) {
pCloned->other = p->other->next;
}

p = pCloned->next;
}
}