JZ3.从尾到头打印链表；JZ14.链表中倒数第K个节点；JZ15.反转链表；JZ16.合并两个有序链表；JZ36.两个链表的第一个公共节点；JZ55.链表中环的入口节点；JZ56.删除链表中重复节点

JZ3. 从尾到头打印链表

题目链接

• 程序代码

/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.*;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        Stack<Integer> stack = new Stack<>();
        ArrayList<Integer> list = new ArrayList<>();
        while(listNode != null) {
            stack.push(listNode.val);
            listNode = listNode.next;
        }
        while(! stack.isEmpty()) {
            list.add(stack.pop());
        }
        return list;
    }
}

• 简单描述

题目要求按链表从尾到头返回一个ArrayList，那我们首先想到的就是定义栈，首先把每个节点的值存入栈里，全部存入后，再弹出到链表中，直到栈为空，此时返回的 list 就是从尾到头打印的结果。

JZ14. 链表中倒数第K个节点

题目链接

• 程序代码

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pHead ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    public ListNode FindKthToTail (ListNode pHead, int k) {
        // write code here
        if(k <= 0) return null;
        ArrayList<ListNode> list = new ArrayList<>();
        while(pHead != null) {
            list.add(pHead);
            pHead = pHead.next;
        }
        int n = list.size();
        if(n < k) return null;
        return list.get(n-k);
    }
}

• 简单描述

首先判断如果k的值 <= 0，没有办法返回值，则返回null；定义一个链表，把节点全部放在链表里，求链表的长度与输入的 k 比较，如果小于 k 的值，则返回null ； 其余情况返回 list.get(n-k)的值

JZ15. 反转链表

题目链接

• 程序代码

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode ReverseList(ListNode head) {
        ListNode newHead = null;
        ListNode prev = null;
        ListNode cur = head;
        while(cur != null) {
            ListNode curNext = cur.next;
            if(curNext == null) {
                newHead = cur;
            }
            cur.next = prev;
            prev = cur;
            cur = curNext;
        }
        return newHead;
    }
}

• 简单描述

要反转一个链表，链表的头节点肯定会变化，所以需要先定义一个空的引用，同时需要定义一个前驱，定义一个傀儡节点curNext，当curNext的值为空时，说明已经到了链表的尾部，这就是新链表的头节点，各个节点的指向如下图所示，最后返回新的头节点即可。

按照代码里的执行顺序就可以对链表进行逆置

JZ16. 合并两个有序链表

题目链接

• 程序代码

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode Merge(ListNode list1,ListNode list2) {
        if(list1 == null && list2 == null) return null;
        if(list1 == null) return list2;
        if(list2 == null) return list1;
        ListNode head = new ListNode(-1);
        ListNode res = head;
        while(list1 != null && list2 != null) {
            if(list1.val < list2.val) {
                head.next = list1;
                head = list1;
                list1 = list1.next;
            } else {
                head.next = list2;
                head = list2;
                list2 = list2.next;
            }
        }
        if(list1 != null) head.next = list1;
        if(list2 != null) head.next = list2;
        return res.next;
    }
}

• 简单描述

定义一个头节点，再定义一个节点保存头节点的值为空，当list1和list2都不为空时，判断list1和list2的值的大小，对其进行拼接，退出while循环时，再判断哪个还有剩余，继续对其进行拼接

JZ36. 两个链表的第一个公共节点

题目链接

• 程序代码

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        if(pHead1 == null || pHead2 == null) return null;
        ListNode p1 = pHead1;
        ListNode p2 = pHead2;
        while(p1 != p2) {
            p1 = p1.next;
            p2 = p2.next;
            if(p1 != p2){
                if(p1 == null) {
                    p1 = pHead2;
                }
                if(p2 == null) {
                    p2 = pHead1;
                }
            }
        }
        return p1;
    }
}

• 简单描述

先判断是否有空，如果有空则没有公共节点。定义p1和p2，当两个节点值不相等时，一直进行循环，不必退出，并且继续往后走，当p1 != p2 且 p1 == null 时，让 p1 = pHead2，p2 同理，最后肯定会相遇，可以参考下面的图进行思考。

JZ55. 链表中环的入口节点

题目链接

• 程序代码

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {

    public ListNode EntryNodeOfLoop(ListNode pHead) {
        ListNode fast = pHead;
        ListNode slow = pHead;
        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if(fast == slow) {
                break;
            }
        }
        //此时退出循环有两种可能
        //1是while条件不符合，2是fast == slow 后 break 退出
        //所以我们先判断是否是while条件不符合
        if(fast == null || fast.next == null) {
            return null;
        }
        fast = pHead;
        while(fast != slow) {
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }
}

• 简单描述

牛客网上一个牛友讲的很好，以下是摘录的他的呀~

1.这题我们可以采用双指针解法，一快一慢指针。快指针每次跑两个element，慢指针每次跑一个。如果存在一个圈，总有一天，快指针是能追上慢指针的。
2.如下图所示，我们先找到快慢指针相遇的点，p。我们再假设，环的入口在点q，从头节点到点q距离为A，q p两点间距离为B，p q两点间距离为C。
3.因为快指针是慢指针的两倍速，且他们在p点相遇，则我们可以得到等式 2(A+B) = A+B+C+B. （感谢评论区大佬们的改正，此处应为：如果环前面的链表很长，而环短，那么快指针进入环以后可能转了好几圈(假设为n圈)才和慢指针相遇。但无论如何，慢指针在进入环的第一圈的时候就会和快的相遇。等式应更正为 2(A+B)= A+ nB + (n-1)C）
4.由3的等式，我们可得，C = A。
5.这时，因为我们的slow指针已经在p，我们可以新建一个另外的指针，slow2，让他从头节点开始走，每次只走下一个，原slow指针继续保持原来的走法，和slow2同样，每次只走下一个。
6.我们期待着slow2和原slow指针的相遇，因为我们知道A=C，所以当他们相遇的点，一定是q了。
7.我们返回slow2或者slow任意一个节点即可，因为此刻他们指向的是同一个节点，即环的起始点，q。

不管是重新建立一个节点slow2，还是让fast = pHead，其实本质都是一样的，我们已经计算出了 A = C ，所以只需要让他们从链表头和相遇点一步步走，终究会在入口点遇见的。

JZ56. 删除链表中重复的节点

题目链接

• 程序代码

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public ListNode deleteDuplication(ListNode pHead) {
        if(pHead == null || pHead.next == null) return pHead;
        ListNode newHead = new ListNode(-1);
        newHead.next = pHead;
        ListNode prev = newHead;
        ListNode cur = newHead.next;
        while(cur != null) {
            if(cur.next != null && cur.val == cur.next.val) {
                while(cur.next != null && cur.val == cur.next.val){
                    cur = cur.next;
                }
                cur = cur.next;
                prev.next = cur;
            } else {
                prev = cur;
                cur = cur.next;
            }
        }
        return newHead.next;
    }
}

• 简单描述

由于头节点可能需要删除，则定义一个新的newHead节点，再定义出prev和cur，当cur不为空时，判断cur.next是否为空，同时判断 cur.val 是否等于 cur.next.val，如果这两个条件都满足，cur 继续往后走，直到条件不满足，其实此时cur的值依然和前面相等，所以我们在退出循环以后，继续让cur再往后走一步，此时让 prev.next = cur，然后继续判断。如果不符合刚刚判断的条件，直接让prev 和 cur都往后走。最后返回newHead.next