常考链表笔试题（三）

1、判断是否是回文
思路：
判断一个链表是否是回文结构，我们可以先找到这个链表的中间节点middle，然后将middle节点之后的链表进行反转，得到一个新链表。
再定义两个引用，分别指向原链表和新链表的第一个节点，然后遍历链表，从第一个结点开始比较，如果两个引用的值不一样，那么就不是回文。
图解过程如下：

所以我们现在要解决两个问题：
1）找到链表的中间结点
这个很简单，遍历链表，求出它的长度，然后用一个for循环[0，len/2]来找中间结点。
2）反转链表
之前也有介绍过，就是从原链表拿下一个节点，然后头插到新链表中。
具体代码如下：

public int length(ListNode head) {
            ListNode cur = head;
            int len = 0;
            while (cur != null) {
                len++;
                cur = cur.next;
            }
            return len;
        }

        public ListNode reverse(ListNode head) {
            ListNode result = null;
            ListNode cur = head;
            while (cur != null) {
                ListNode next = cur.next;

                //头插
                cur.next = result;
                result = cur;

                cur = next;
            }
            return result;
        }


        public boolean chkPalindrome(ListNode A) {
            int len = length(A);
            int halfLen = len / 2;

            //找中间结点
            ListNode middle = A;
            for (int i = 0; i < halfLen; i++) {
                middle = middle.next;
            }

            ListNode r = reverse(middle);
            ListNode c1 = A;
            ListNode c2 = r;

            while (c1 != null && c2 != null) {
                if (c1.val != c2.val) {
                    return false;
                }
                c1 = c1.next;
                c2 = c2.next;
            }
            return true;
        }

2、在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。
示例：
链表1->2->3->3->4->4->5，处理后为 1->2->5
思路：
定义两个引用p1和p2分别指向链表的第一个和第二个节点，再定义一个p1的前驱结点的引用prev，为了消除第一个节点没有前驱的特殊性，我们还需要定义一个假结点dummy，如下图：

然后从第一个节点开始比较，如果p1和p2的值不相等，那么prev，p1，p2三个引用依次往后移一个，否则的话需要删除p1和p2节点。
删除的方法也很简单，p2向后走一个，让prev的next引用直接指向p2节点，这就实现了删除。接着让p1引用也指向p2节点，如果p2节点不为空，就让p2引用指向下一个节点，然后重复上述步骤即可，第一次删除后的链表为下图中红色部分：

具体实现代码如下：

public ListNode deleteDuplication(ListNode pHead) {
            if (pHead == null) {
                return null;
            }

            //消除第一个结点没有前驱的特殊性
            ListNode dummy = new ListNode(0);
            dummy.next = pHead;
            ListNode prev = dummy;      //prev永远是p1的前驱结点，用来删除结点
            //p1和p2是进行比较的两个节点
            ListNode p1 = pHead;
            ListNode p2 = pHead.next;

            while (p2 != null) {
                if (p1.val != p2.val) {
                    //因为有序，p1和p2不等，和p2的next更不会相等
                    prev = prev.next;
                    p1 = p1.next;
                    p2 = p2.next;
                } else {
                    while (p2 != null && p2.val == p1.val) {
                        p2 = p2.next;
                    }

                    //删除结点
                    prev.next = p2;

                    p1 = p2;
                    if (p2 != null) {
                        p2 = p2.next;
                    }
                }
            }
            return dummy.next;
        }

3、编写一个程序，找到两个单链表相交的起始节点。
示例：

思路：
求出两条链表的长度差，再定义两个引用shorter和longer分别指向两条链表的头节点，让指向较长链表的那个引用longer先走长度差步，相当于让二者站在同一起跑线上。
当两个引用的指向不同时，让这两个引用同时向后遍历，注意，是比较这两个引用，而不是比较它们的值，最后返回longer或shorter，这个就是两条链表最开始相交的节点。

具体代码如下：

private int getLength(ListNode head) {
            int length = 0;
            for (ListNode cur = head; cur != null; cur = cur.next) {
                length++;
            }
            return length;
        }

        public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
            int lenA = getLength(headA);
            int lenB = getLength(headB);
            ListNode longer = headA;
            ListNode shorter = headB;
            int diff = lenA - lenB;
            if (lenA < lenB) {
                diff = lenB - lenA;
                longer = headB;
                shorter = headA;
            }

            for (int i = 0; i < diff; i++) {
                longer = longer.next;
            }

            while (longer != shorter) {
                longer = longer.next;
                shorter = shorter.next;
            }

            return longer;
        }