链表的经典问题

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

如果两个单链表相交，那应该呈“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 listif (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 nodewhile (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 endHead = 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;
}

链表的排序

归并排序实现的时间复杂度为 nlgn，

struct ListNode* Merge(struct ListNode* p1, struct ListNode *p2) {if (!p1) return p2;if (!p2) return p1;if (p1->val > p2->val) {p2->next = Merge(p1, p2->next);return p2;} else {p1->next = Merge(p1->next, p2);return p1;}}struct ListNode* sortList(struct ListNode* head) {if (!head || !head->next) return head;struct ListNode *h1, *h2;struct ListNode *p1 = head, *p2 = head, *p = head;while (p2 && p2->next) {p = p1;p1 = p1->next;p2 = p2->next->next;}p->next = NULL;h1 = sortList(p1);h2 = sortList(head);return Merge(h1, h2);
}

以上递归的实现会占用lgN的空间（递归压栈），非递归的实现如下：

复杂链表的复制

假设有一个复杂链表，它除了有一个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(n²)。

上面这种方法的主要缺点在于无法快速定位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;}
}