收集一些关于链表的常见面试笔试题。
链表结构：
typedef struct ListNode { int val; ListNode* next; }ListNode;
1. 链表反转
思路：将需要反转的结点的下一个结点暂存起来，然后将需要反转的结点与它指向的下一个结点交换指针位置，交换完毕以后，再将指针指向暂存的结点即可，这样相当于是改变了链表指针的指向，同时要注意到，返回值是原先链表的链表尾，可以通过判断下一结点是否为空，如果为空则说明到达链表末尾，此时就可以将结果返回，链表已经被反转成功。
ListNode* reverseList(ListNode* pHead) { if (pHead == NULL || pHead->next == NULL) //链表为空或者仅1个数直接返回 return pHead; ListNode* p = pHead, *res= NULL; //定义一个节点，保存最终结果 ListNode* temp; while (p != NULL) //循环到链尾 { temp = p->next; //暂存p下一个地址，防止变化指针指向后找不到后续的数 p->next = res; //p->next指向前一个空间 res = p; //新链表的头移动到p，扩长一步链表 p = temp; //p指向原始链表p指向的下一个空间 } return res; }
2. 从尾到头输出单链表
思路：
1）从头到尾遍历链表，每经过一个节点的时候，把该节点放到栈中。当遍历完整个链表后，再从栈顶开始输出结点的值，此时输出的节点的顺序已经反转过来了。该方法需要维护一个额外的栈空间；
2）既然想到了栈来实现这个函数，而递归本质上就是一个栈结构，于是可以用递归来实现。要实现反过来输出链表，每访问一个节点的时候，先递归输出到它后面的节点，再输出该节点自身，这样即链表的输出结果就反过来了。
思路1实现：
void PrintListReverse(ListNode *pHead) { stack<ListNode*> s_node; ListNode* tmp = pHead; while(temp != NULL) { s_node.push(temp); temp = temp->next; } while(!s_node.empty()) { printf("%d",s_node.top()->val); s_node.pop(); } }
思路2：
void PrintListReverse(ListNode *pHead) { if(pHead != NULL) { PrintListReverse(pHead->next); //先递归输出到它后面的节点 } printf("%d", pHead->val); //输出后一个节点自身 }
此题还有两个常见的变体：
（1）从尾到头输出一个字符串；
（2）定义一个函数求字符串的长度，要求该函数体内不能声明任何变量；
对于这两个变体，都可以参考思路2的实现方式。
3. 合并两个有序链表
思路：逐个比较两个链表的元素，较小的元素进入到新的链表中，并且指向它的下一个。递归法实现。
ListNode* Merge(ListNode* n1, ListNode* n2) { if (n1 == NULL) { return n2; } else if (n2 == NULL) { return n1; } ListNode* res = NULL; if (n1->val < n2->val) { res = n1; res->next = Merge(n1->next, n2); } else { res = n2; res->next = Merge(n1, n2->next); } return res; }
4. 判断单链表是否有环
此题有很多种方法，这里介绍一种比较巧妙的方法，使用STL中的map实现。
思路：首先定义 map<ListNode*,int> m; 将一个ListNode*指针映射成数组的下标，并赋值为一个int类型的数值。然后从链表的头指针开始往后遍历，每次遇到一个指针p，就判断m[p]是否为0。如果为0，则将m[p]赋值为1，表示该节点是第一次访问；而如果m[p]的值为1，则说明这个节点已经被访问过一次了，于是就形成了环。
map<ListNode*, int> m; bool IsLoop(ListNode *phead) { if(pHead == NULL) return false; ListNode* p = pHead; while(p != NULL) { if(m[p] == 0) m[p] = 1; else if(m[p] == 1) return true; p = p->next; } }
延伸：找到有环链表的环入口
思路：
//断链法：破坏链表结构
/*
时间复杂度为O（n），两个指针，一个在前面（front），另一个(pre)紧邻着这个指针，在后面。
两个指针同时向前移动，每移动一次，令前面的指针的next指向NULL。
也就是说：访问过的节点都断开，最后到达的那个节点一定是尾节点的下一个，
也就是循环的第一个。
这时候已经是第二次访问循环的第一节点了，第一次访问的时候我们已经让它指向了NULL，
所以到这结束。
*/
ListNode* EntryNodeOfLoop(ListNode* pHead) { if(!pHead->next) return NULL; ListNode* pre = pHead; ListNode* front = pHead->next; while(front){ pre->next = NULL; pre=front; front = front->next; } return pre; }
5. 找到链表的倒数第k个节点
思路：创建两个指针，先让第一个指针和第二个指针都指向头结点，然后再让第一个指针走(k-1)步，到达第k个节点，然后两个指针同时往后移动，当第一个结点到达末尾的时候，第二个结点所在位置就是倒数第k个节点了
ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) { ListNode *pHead = pListHead; ListNode *pTail = pListHead; if(pListHead==NULL || k==0) return NULL; for(int i=1;i<k;++i){ if(pTail->next != NULL) { pTail=pTail->next; } else return NULL; } while(pTail->next!=NULL) { pTail=pTail->next; pHead = pHead->next; } return pHead; }
6. 求两个链表的公共节点
ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) { ListNode* p1 = pHead1; ListNode* p2 = pHead2; while(p1!=p2){ p1 = (p1==NULL ? pHead2 : p1->next); p2 = (p2==NULL ? pHead1 : p2->next); } return p1; }
7. 删除有序链表中的重复结点
在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5
采用递归法：
ListNode* deleteDuplication(ListNode* pHead) { if(pHead==NULL) return NULL; if(pHead!=NULL && pHead->next==NULL) return pHead; ListNode* cur; if(pHead->next->val == pHead->val){ cur=pHead->next->next; while(cur!=NULL && cur->val==pHead->val) cur=current->next; return deleteDuplication(cur); } else{ cur = pHead->next; pHead->next = deleteDuplication(cur); return pHead; } }
先总结到这里，后面再补充~