转自：http://blog.csdn.net/luckyxiaoqiang/article/details/7393134/#topic9
链表是最基本的数据结构，面试官也常常用链表来考察面试者的基本能力，而且链表相关的操作相对而言比较简单，也适合考察写代码的能力。链表的操作也离不开指针，指针又很容易导致出错。综合多方面的原因，链表题目在面试中占据着很重要的地位。本文对链表相关的面试题做了较为全面的整理，希望能对找工作的同学有所帮助。
链表结点声明如下：
struct ListNode
{
int m_nKey;
ListNode * m_pNext;
};
题目列表：
1. 求单链表中结点的个数
2. 将单链表反转
3. 查找单链表中的倒数第K个结点（k > 0）
4. 查找单链表的中间结点
5. 从尾到头打印单链表
6. 已知两个单链表pHead1 和pHead2 各自有序，把它们合并成一个链表依然有序
7. 判断一个单链表中是否有环
8. 判断两个单链表是否相交
9. 求两个单链表相交的第一个节点
10. 已知一个单链表中存在环，求进入环中的第一个节点
11. 给出一单链表头指针pHead和一节点指针pToBeDeleted，O(1)时间复杂度删除节点pToBeDeleted
详细解答
这是最最基本的了，应该能够迅速写出正确的代码，注意检查链表是否为空。时间复杂度为O（n）。参考代码如下：
从头到尾遍历原链表，每遍历一个结点，将其摘下放在新链表的最前端。注意链表为空和只有一个结点的情况。时间复杂度为O（n）。参考代码如下：
3. 查找单链表中的倒数第K个结点（k > 0）
最普遍的方法是，先统计单链表中结点的个数，然后再找到第（n-k）个结点。注意链表为空，k为0，k为1，k大于链表中节点个数时的情况。时间复杂度为O（n）。代码略。
这里主要讲一下另一个思路，这种思路在其他题目中也会有应用。
主要思路就是使用两个指针，先让前面的指针走到正向第k个结点，这样前后两个指针的距离差是k-1，之后前后两个指针一起向前走，前面的指针走到最后一个结点时，后面指针所指结点就是倒数第k个结点。
参考代码如下：
4. 查找单链表的中间结点
此题可应用于上一题类似的思想。也是设置两个指针，只不过这里是，两个指针同时向前走，前面的指针每次走两步，后面的指针每次走一步，前面的指针走到最后一个结点时，后面的指针所指结点就是中间结点，即第（n/2+1）个结点。注意链表为空，链表结点个数为1和2的情况。时间复杂度O（n）。参考代码如下：
对于这种颠倒顺序的问题，我们应该就会想到栈，后进先出。所以，这一题要么自己使用栈，要么让系统使用栈，也就是递归。注意链表为空的情况。时间复杂度为O（n）。参考代码如下：
自己使用栈：
使用递归函数：
6. 已知两个单链表pHead1 和pHead2 各自有序，把它们合并成一个链表依然有序
这个类似归并排序。尤其注意两个链表都为空，和其中一个为空时的情况。只需要O（1）的空间。时间复杂度为O（max(len1, len2)）。参考代码如下：
也有如下递归解法：
这里也是用到两个指针。如果一个链表中有环，也就是说用一个指针去遍历，是永远走不到头的。因此，我们可以用两个指针去遍历，一个指针一次走两步，一个指针一次走一步，如果有环，两个指针肯定会在环中相遇。时间复杂度为O（n）。参考代码如下：
如果两个链表相交于某一节点，那么在这个相交节点之后的所有节点都是两个链表所共有的。也就是说，如果两个链表相交，那么最后一个节点肯定是共有的。先遍历第一个链表，记住最后一个节点，然后遍历第二个链表，到最后一个节点时和第一个链表的最后一个节点做比较，如果相同，则相交，否则不相交。时间复杂度为O(len1+len2)，因为只需要一个额外指针保存最后一个节点地址，空间复杂度为O(1)。参考代码如下：
9. 求两个单链表相交的第一个节点
对第一个链表遍历，计算长度len1，同时保存最后一个节点的地址。
对第二个链表遍历，计算长度len2，同时检查最后一个节点是否和第一个链表的最后一个节点相同，若不相同，不相交，结束。
两个链表均从头节点开始，假设len1大于len2，那么将第一个链表先遍历len1-len2个节点，此时两个链表当前节点到第一个相交节点的距离就相等了，然后一起向后遍历，知道两个节点的地址相同。
时间复杂度，O(len1+len2)。参考代码如下：
10. 已知一个单链表中存在环，求进入环中的第一个节点
首先判断是否存在环，若不存在结束。在环中的一个节点处断开（当然函数结束时不能破坏原链表），这样就形成了两个相交的单链表，求进入环中的第一个节点也就转换成了求两个单链表相交的第一个节点。参考代码如下：
11. 给出一单链表头指针pHead和一节点指针pToBeDeleted，O(1)时间复杂度删除节点pToBeDeleted
对于删除节点，我们普通的思路就是让该节点的前一个节点指向该节点的下一个节点，这种情况需要遍历找到该节点的前一个节点，时间复杂度为O(n)。对于链表，链表中的每个节点结构都是一样的，所以我们可以把该节点的下一个节点的数据复制到该节点，然后删除下一个节点即可。要注意最后一个节点的情况，这个时候只能用常见的方法来操作，先找到前一个节点，但总体的平均时间复杂度还是O(1)。参考代码如下：
java实现版本
package test;
import java.util.Stack;
public class TestList {
static class ListNode{
private ListNode pre;
private ListNode next;
private int data;
public ListNode getPre() {
return pre;
}
public void setPre(ListNode pre) {
this.pre = pre;
}
public ListNode getNext() {
return next;
}
public void setNext(ListNode next) {
this.next = next;
}
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
}
/**
* 反转链表
* @param head
* @return
*/
public ListNode reverseListNode(ListNode head){
if(head == null){
return null;
}
if(head.getNext() == null){
return head;
}
ListNode currentNode = head;
while(currentNode != null){
ListNode currentPre = currentNode.getPre();
ListNode currentNext = currentNode.getNext();
// 反转指向
currentNode.setNext(currentPre);
currentNode.setPre(currentNext);
if(currentNext != null){
currentNode = currentNext;
}else{
break;
}
}
return currentNode;
}
// 查找单链表中的倒数第K个结点（k > 0）
public ListNode findKNode(ListNode head, int k){
if(head == null){
return null;
}
ListNode node1 = head;
ListNode node2 = head;
for(int index = 1; index < k; index++){
node2 = node2.getNext();
if(node2 == null){
return null;
}
}
while(node2.getNext() != null){
node1 = node1.getNext();
node2 = node2.getNext();
}
return node1;
}
// 查找单链表的中间结点
public ListNode findMiddleNode(ListNode head){
if(head == null){
return null;
}
ListNode node1 = head;
ListNode node2 = head;
while(node2.getNext() != null && node2.getNext().getNext() != null){
node1 = node1.getNext();
node2 = node2.getNext().getNext();
}
return node1;
}
// 从尾到头打印单链表
public void printEndToStartNode(ListNode head){
Stack<ListNode> nodeStack = new Stack<>();
nodeStack.push(head);
while(head.getNext() != null){
nodeStack.push(head.getNext());
head = head.getNext();
}
while(!nodeStack.isEmpty()){
ListNode node = nodeStack.pop();
if(node != null){
System.out.println(node.getData());
}
}
}
// 6. 已知两个单链表pHead1 和pHead2 各自有序，把它们合并成一个链表依然有序
public ListNode mergeList(ListNode head1,ListNode head2){
ListNode list1 = head1;
ListNode list2 = head2;
ListNode mergeNodeList = null;
if(list1 == null && list2 != null){
mergeNodeList = list2;
list2 = list2.getNext();
}else if(list1 != null && list2 == null){
mergeNodeList = list1;
list1 = list1.getNext();
}else if(list1 != null && list2 != null){
if(list1.getData() > list2.getData()){
mergeNodeList = list2;
list2 = list2.getNext();
}else{
mergeNodeList = list1;
list1 = list1.getNext();
}
}else{
return null;
}
ListNode resultMergeNodeList = mergeNodeList;
while(list1 != null || list2 != null){
if(list1 == null && list2 != null){
mergeNodeList.setNext(list2);
mergeNodeList.getNext().setPre(mergeNodeList);
mergeNodeList = mergeNodeList.getNext();
list2 = list2.getNext();
}else if(list1 != null && list2 == null){
mergeNodeList.setNext(list1);
mergeNodeList.getNext().setPre(mergeNodeList);
mergeNodeList = mergeNodeList.getNext();
list1 = list1.getNext();
}else if(list1 != null && list2 != null){
if(list1.getData() > list2.getData()){
mergeNodeList.setNext(list2);
mergeNodeList.getNext().setPre(mergeNodeList);
list2 = list2.getNext();
mergeNodeList = mergeNodeList.getNext();
}else{
mergeNodeList.setNext(list1);
mergeNodeList.getNext().setPre(mergeNodeList);
list1 = list1.getNext();
mergeNodeList = mergeNodeList.getNext();
}
}else{
break;
}
}
return resultMergeNodeList;
}
// 是否有环
public boolean isHaveCircle(ListNode head){
ListNode list1 = head;
ListNode list2 = head;
while(list2 != null && list2.getNext() != null){
list1 = list1.getNext();
list2 = list2.getNext().getNext();
if(list1 == null || list2 == null){
return false;
}
if(list1.getData() == list2.getData() && list1.getNext() == list2.getNext()){
System.out.println("找到还，环节点为 = " + list1.getData());
return true;
}
}
return false;
}
// 判断两个单链表是否相交
public boolean isNodeListXJ(ListNode head1, ListNode head2){
int len1 = getListLen(head1);
int len2 = getListLen(head2);
if(len1 > len2){
int firstGo = len1 - len2;
while(firstGo-- > 0){
head1 = head1.getNext();
}
}else if(len1 < len2){
int firstGo = len2 - len1;
while(firstGo-- > 0){
head2 = head2.getNext();
}
}
while(head1 != null && head2 != null){
if(head1.getData() == head2.getData() && head1.getNext() == head2.getNext()){
return true;
}
head1 = head1.getNext();
head2 = head2.getNext();
}
return false;
}
/**
* 已知一个单链表中存在环，求进入环中的第一个节点
* @return
*/
public ListNode getCircleFirstNode(ListNode head){
// 找到相交的点
ListNode list1 = head;
ListNode list2 = head;
ListNode findNode = null;
while(list2 != null && list2.getNext() != null){
list1 = list1.getNext();
list2 = list2.getNext().getNext();
if(list1 == null || list2 == null){
return null;
}
if(list1.getData() == list2.getData() && list1.getNext() == list2.getNext()){
System.out.println("找到还，环节点为 = " + list1.getData());
findNode = list1;
break;
}
}
// 断开该node findNode
ListNode head2 = findNode.getNext();
findNode.setNext(null);
int len1 = getListLen(head);
int len2 = getListLen(head2);
if(len1 > len2){
int firstGo = len1 - len2;
while(firstGo-- > 0){
head = head.getNext();
}
}else if(len1 < len2){
int firstGo = len2 - len1;
while(firstGo-- > 0){
head2 = head2.getNext();
}
}
while(head != null && head2 != null){
if(head.getData() == head2.getData() && head.getNext() == head2.getNext()){
return head;
}
head = head.getNext();
head2 = head2.getNext();
}
return null;
}
/**
*
* 给出一单链表头指针pHead和一节点指针pToBeDeleted，O(1)时间复杂度删除节点pToBeDeleted
* @param head
* @param deleteNode
*/
public void deleteListNode(ListNode head, ListNode deleteNode){
if(deleteNode == null){
return;
}
if(deleteNode.getNext() == null){
if(head == deleteNode){
head = null;
}else{
while(head.getNext() != deleteNode){
head = head.getNext();
}
head.setNext(null);
deleteNode = null;
}
}else{
ListNode nextNode = deleteNode.getNext();
deleteNode.setData(deleteNode.getNext().getData());
deleteNode.setNext(deleteNode.getNext().getNext());
nextNode = null;
}
}
private int getListLen(ListNode head){
if(head == null){
return 0;
}
int count = 0;
while(head != null){
count++;
head = head.getNext();
}
return count;
}
public static void main(String[] args) {
ListNode head = new ListNode();
head.setData(1);
head.setPre(null);
head.setNext(null);
ListNode currentNode = head;
ListNode node3 = null;
for(int index = 1;index < 20; index ++){
ListNode node = new ListNode();
node.setData(index+1);
currentNode.setNext(node);
if(index == 6){
node3 = node;
}
node.setPre(currentNode);
currentNode = currentNode.getNext();
}
// 查找单链表中的倒数第K个结点（k > 0） OK
/*ListNode beforeReverseNode = head;
System.out.print(beforeReverseNode.getData() + ",");
while(beforeReverseNode.getNext() != null){
beforeReverseNode = beforeReverseNode.getNext();
System.out.print(beforeReverseNode.getData() + ",");
}
ListNode reverseNode = new TestList().reverseListNode(head);
System.out.println("反转后:");
System.out.print(reverseNode.getData() + ",");
while(reverseNode.getNext() != null){
reverseNode = reverseNode.getNext();
System.out.print(reverseNode.getData() + ",");
}*/
// 查找单链表中的倒数第K个结点（k > 0）
/*
ListNode kNode = new TestList().findKNode(head, 20);
if(kNode != null){
System.out.println(kNode.getData());
}else{
System.out.println("不存在倒数k节点");
}*/
// 查找单链表的中间结点
/*ListNode middleNode = new TestList().findMiddleNode( head);
if(middleNode != null){
System.out.println(middleNode.getData());
}else{
System.out.println("不存在中间节点");
}*/
// // 从尾到头打印单链表
/*
new TestList().printEndToStartNode(head);
*/
// 已知两个单链表pHead1 和pHead2 各自有序，把它们合并成一个链表依然有序
/*ListNode head2 = new ListNode();
head2.setData(1);
head2.setPre(null);
head2.setNext(null);
ListNode currentNode2 = head2;
for(int index = 1;index < 15; index = index + 2){
ListNode node = new ListNode();
node.setData(index+1);
currentNode2.setNext(node);
node.setPre(currentNode2);
currentNode2 = currentNode2.getNext();
}
ListNode mergeNodeList = new TestList().mergeList(head, head2);
while(mergeNodeList != null){
System.out.println(mergeNodeList.getData());
mergeNodeList = mergeNodeList.getNext();
}*/
// 判断一个单链表中是否有环
/*currentNode.setNext(node3);
if(new TestList().isHaveCircle(head)){
System.out.println("有环");
}else{
System.out.println("无环");
}*/
// 判断两个单链表是否相交
/*ListNode head2 = new ListNode();
head2.setData(1);
head2.setPre(null);
head2.setNext(null);
ListNode currentNode2 = head2;
for(int index = 1;index < 15; index = index + 2){
ListNode node = new ListNode();
node.setData(index+1);
currentNode2.setNext(node);
node.setPre(currentNode2);
currentNode2 = currentNode2.getNext();
}
currentNode2.setNext(node3);
if(new TestList().isNodeListXJ(head, head2)){
System.out.println("相交");
}else{
System.out.println("NO");
}*/
// 求两个单链表相交的第一个节点
// 已知一个单链表中存在环，求进入环中的第一个节点
/*currentNode.setNext(node3);
ListNode findNode = new TestList().getCircleFirstNode(head);
if(findNode != null){
System.out.println(findNode.getData());
}else{
System.out.println("没有");
}*/
// 给出一单链表头指针pHead和一节点指针pToBeDeleted，O(1)时间复杂度删除节点pToBeDeleted
}
}