链表作为常考的面试题，并且本身比较灵活，对指针的应用较多。本文对常见的链表面试题Java实现做了整理。

链表节点定义如下:

static class Node {
    int num;
    Node next;
}

1. 求单链表中结点的个数

依次遍历链表

public static int size(Node head) {
    int size = 0;
    while (head != null) {
        size++;
        head = head.next;
    }
    return size;
}

2. 将单链表反转

构建一个新的链表，依次将本链表的节点插入到新链表的最前端，即可完成链表的反转。

public static Node reverse(Node head) {
    Node p1 = head, p2;
    head = null;
    while (p1 != null) {
        p2 = p1;
        p1 = p1.next;

        //头插法
        p2.next = head;
        head = p2;
    }
    return head;
}

3. 查找单链表中的倒数第K个结点（k > 0）

第一种解法是得到顺数的第 size+k-1 个节点，即为倒数的第K歌节点
第二种解法是快慢指针,主要思路就是使用两个指针，先让前面的指针走到正向第k个结点，后面的指针才走，这样前后两个指针的距离差是k-1，之后前后两个指针一起向前走，前面的指针走到最后一个结点时，后面指针所指结点就是倒数第k个结点，下面采用这种解法。

public static Node getKNode(Node head, int k) {
    if (k < 0 || head == null) {
        return null;
    }
    Node p2 = head, p1 = head;
    while (k-- > 1 && p1 != null) {
        p1 = p1.next;
    }
    // 说明k>size，因此返回null
    if (k > 1 || p1 == null) {
        return null;
    }
    while (p1.next != null) {
        p1 = p1.next;
        p2 = p2.next;
    }
    return p2;
}

4. 查找单链表的中间结点

采用快慢指针，p1每次走两步，p2每次走一步，奇数返回size/2+1，偶数返回size/2,
注意链表为空，链表结点个数为1和2的情况。

public static Node getMidNode(Node head) {
    if (head == null) {
        return null;
    }
    Node p1 = head, p2 = head;
    while (p1.next != null) {
        if (p1 == null) {
            break;
        }
        p1 = p1.next.next;
        p2 = p2.next;

    }
    return p2;
}

5. 从尾到头打印单链表

用栈

public static void reversePrint(Node node) {
    Stack<Node> stack = new Stack<>();
    while (node != null) {
        stack.push(node);
        node = node.next;
    }
    while (!stack.isEmpty()) {
        System.out.print(stack.pop().num + " ");
    }

}

递归

public static void reversePrint2(Node node) {
    if (node != null) {
        reversePrint2(node.next);
        System.out.print(node.num + " ");
    }
}

6. 已知两个单链表pHead1和pHead2各自有序，把它们合并成一个链表依然有序

类似于归并排序

public static Node merge(Node head1, Node head2) {
    Node p1 = head1, p2 = head2, head;
    if (head1.num < head2.num) {
        head = head1;
        p1 = p1.next;
    } else {
        head = head2;
        p2 = p2.next;
    }

    Node p = head;
    while (p1 != null && p2 != null) {
        if (p1.num <= p2.num) {
            p.next = p1;
            p1 = p1.next;
            p = p.next;
        } else {
            p.next = p2;
            p2 = p2.next;
            p = p.next;
        }
    }
    if (p1 != null) {
        p.next = p1;
    }
    if (p2 != null) {
        p.next = p2;
    }
    return head;
}

7. 判断一个单链表中是否有环

这里也是用到两个指针。如果一个链表中有环，也就是说用一个指针去遍历，是永远走不到头的。因此，我们可以用两个指针去遍历，一个指针一次走两步，一个指针一次走一步，如果有环，两个指针肯定会在环中相遇。时间复杂度为O（n）。

public static boolean hasRing(Node head) {
    Node p1 = head, p2 = head;
    while (p1 != null && p1.next != null) {
        p1 = p1.next.next;
        p2 = p2.next;
        if (p1 == p2) {
            return true;
        }
    }
    return false;
}

8. 已知一个单链表中存在环，求进入环中的第一个节点

解题思路：

由上题可知，按照 p1 每次两步，p2 每次一步的方式走，发现 p2 和 p1 重合，确定了单向链表有环路了。接下来，让 p1 回到链表的头部，重新走，每次步长不是走2了，而是走1，那么当 p1 和 p2 再次相遇的时候，就是环路的入口了。

为什么？

假定起点到环入口点的距离为 a，p1 和 p2 的相交点M与环入口点的距离为b，环路的周长为L，当 p1 和 p2 第一次相遇的时候，假定 p2 走了 n 步。那么有：

p2走的路径： a+b ＝ n；
p1走的路径： a+b+kL = 2n； p1 比 p2 多走了k圈环路，总路程是p2的2倍

根据上述公式可以得到 k*L=a+b=n ，显然，如果从相遇点M开始，p2 再走 n 步的话，还可以再回到相遇点，同时p2从头开始走的话，经过n步，也会达到相遇点M。

显然在这个步骤当中 p1 和 p2 只有前 a 步走的路径不同，所以当 p1 和 p2 再次重合的时候，必然是在链表的环路入口点上。

public static Node getFirstRingNode(Node head) {
    Node p1 = head, p2 = head;
    while (p1 != null && p1.next != null) {
        p1 = p1.next.next;
        p2 = p2.next;
        if (p1 == p2) {
            p1 = head;
            while (p1 != p2) {
                p1 = p1.next;
                p2 = p2.next;
            }
            break;
        }
    }
    return p1;
}

9. 判断两个单链表是否相交

如果两个链表相交，那么相交之后的节点应该相同，那么最后那个节点应该也相同

public static boolean isIntersect(Node head1, Node head2) {
    Node p1 = head1, p2 = head2;
    while (p1.next != null) {
        p1 = p1.next;
    }
    while (p2.next != null) {
        p2 = p2.next;
    }
    return p1 == p2;
}

10. 求两个单链表相交的第一个节点

采用对齐的思想。计算两个链表的长度 L1 , L2，分别用两个指针 p1 , p2 指向两个链表的头，
然后将较长链表的 p1（假设为 p1）向后移动L2 - L1个节点，然后再同时向后移动p1 , p2，
直到 p1 = p2。相遇的点就是相交的第一个节点。

public static Node firstIntersectNode(Node head1, Node head2) {
    int len1 = size(head1);
    int len2 = size(head2);
    Node p1 = head1, p2 = head2;
    if (len1 > len2) {
        for (int i = 1; i < len1 - len2; i++) {
            p1 = p1.next;
        }
    } else {
        for (int i = 1; i < len2 - len1; i++) {
            p2 = p2.next;
        }
    }
    while (p1 != p2) {
        p1 = p1.next;
        p2 = p2.next;
    }

    return p1;
}

11. 给出一单链表头指针 head 和一节点指针 deletedNode，O(1)时间复杂度删除节点deletedNode

将deletedNode下一个节点的值复制给deletedNode节点，然后删除deletedNode节点，但是对于要删除的节点是最后一个节点的时候要做处理。

public static Node firstIntersectNode(Node head1, Node head2) {
    int len1 = size(head1);
    int len2 = size(head2);
    Node p1 = head1, p2 = head2;
    if (len1 > len2) {
        for (int i = 1; i < len1 - len2; i++) {
            p1 = p1.next;
        }
    } else {
        for (int i = 1; i < len2 - len1; i++) {
            p2 = p2.next;
        }
    }
    while (p1 != p2) {
        p1 = p1.next;
        p2 = p2.next;
    }

    return p1;
}

12. 链表的冒泡排序

对于数组的冒泡排序是上层for循环控制次数，下次for循环控制距离，对于链表的冒泡排序而言，首先让tail指针为null，一次循环比较完之后，在等于最后一个节点，倒数第二个节点。。。就是通过tail指针控制循环比较的次数和距离。

public static void bubbleSort(Node head) {
    Node tail = null;
    Node p1;
    while (head != tail) {
        for (p1 = head; p1.next != tail; p1 = p1.next) {
            if (p1.num > p1.next.num) {
                int temp = p1.num;
                p1.num = p1.next.num;
                p1.next.num = temp;
            }
        }
        tail = p1;
    }
    show(head);
}

13. 单链表的双冒泡排序

public static void doubleBubblesort(Node start, Node end) {
    if (start != end) {
        Node p1 = start;
        Node p2 = p1.next;
        while (p2 != end) {
            if (p2.num < start.num) {
                p1 = p1.next;
                int temp = p1.num;
                p1.num = p2.num;
                p2.num = temp;
            }
            p2 = p2.next;
        }
        int temp = p1.num;
        p1.num = start.num;
        start.num = temp;
        doubleBubblesort(start, p1);
        doubleBubblesort(p1.next, null);
    }

}

全部代码放在 https://github.com/morethink/algorithm/blob/master/src/main/java/algorithm/list/LinkedList.java

参考文档