数据结构-LeetCode刷题(链表）(下)

(LeetCode 160)相交链表

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。
图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。

方法一 双指针

两指针从两个单链表的头开始移动，当两个中的任意一个指针指向null，即遍历到链表结尾时，该指针从另一个链表开始遍历，另一个指针同理，直到两指针同时指向同一个结点或null。
只要俩链表有相交的地方，就一定会在同一个结点遇到。
进阶：你能否设计一个时间复杂度 O(m + n) 、仅用 O(1) 内存的解决方案？

• 问题已理解

  public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        if(headA == null || headB == null){
            return null;
        }
        ListNode pA = headA,pB = headB;
        while(pA!= pB){
            pA = pA == null ? headB : pA.next;
            pB = pB == null ? headA : pB.next;
        } 
        return pA;
    }

方法二 “同一位置”开始遍历

先比较得出两链表的长度，再相减，即让两指针从“同一位置”开始遍历，只要有相连的地方，则一定会相遇。

• 问题已理解

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int L1=0,L2=0,diff=0;
        ListNode head1 = headA,head2 = headB;
        while(head1 != null){
            L1++;
            head1 = head1.next;
        }
        while(head2 != null){
            L2++;
            head2 = head2.next;
        }
        if(L1 < L2){
            head1 = headB;
            head2 = headA;
            diff = L2 - L1;
        }else{
            head1 = headA;
            head2 = headB;
            diff = L1 - L2;
        }

        for(int i = 0;i < diff;i++){
            head1 = head1.next;
        }
        while(head1 != null && head2 != null){
            if(head1 == head2)
                return head1;
            head1 = head1.next;
            head2 = head2.next;
        }
        return null;
    }

(LeetCode 206)反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

方法 不断分离链表

①ListNode next = curr.next; 这一步是为了保存切割下来的后续链表
②curr.next = preNode; 切割链表
③preNode = curr; 将切割下的链表连到新链表中
④curr = next; 恢复原有链表并指向下一个结点
重要的是②③步的理解：准确的来说③是切割，②是连接。

• 问题已理解

  public ListNode reverseList(ListNode head) {
        ListNode preNode = null;
        ListNode curr = head;
        while(curr != null){
        	//重点代码
            ListNode next = curr.next;
            curr.next = preNode;
            preNode = curr;
            curr = next;
        }
        return preNode;
    }

(LeetCode 234)回文链表

给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。

进阶：你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？

方法 先反转再比较

快慢双指针以2：1的速度遍历链表。
通过遍历得出链表的长度：偶数对半分，奇数把中间结点归到左边链表。
然后反转右边的链表，再比较两个链表的值(比较时遍历短的链表，即右边的链表)

• 问题已理解

   public boolean isPalindrome(ListNode head) {
        ListNode fast = head,slow = head;
        while(fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
        }
        //链表是奇数个，中间的归到左边
        if(fast != null){
            slow = slow.next;
        }
        slow = reverseList(slow);
        fast = head;

        while(slow != null){
            if(fast.val != slow.val){
                return false;
            }
            fast = fast.next;
            slow = slow.next;
        }
        return true;
    }

    //反转链表
    public ListNode reverseList(ListNode head) {
        ListNode preNode = null;
        while(head != null){
            ListNode next = head.next;
            head.next = preNode;
            preNode = head;
            head = next;
        }
        return preNode;
    }

(LeetCode 876)链表的中间结点

给你单链表的头结点 head ，请你找出并返回链表的中间结点。
如果有两个中间结点，则返回第二个中间结点。

方法 双指针遍历

与回文链表中提到的解法有关，快慢双指针以2：1的速度遍历链表。
当快指针指向null时，说明链表长度是偶数，慢指针指的是第二个中间结点
当快指针下一个结点指向null时，说明链表长度是奇数，慢指针指的是中间结点

• 问题已理解

 public ListNode middleNode(ListNode head) {
        ListNode slow = head,fast = head;
        while(fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }

(剑指Offer 22)链表中倒数第K个结点

输入一个链表，输出该链表中倒数第k个结点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾结点时倒数第一个结点。
如一个有6个结点的链表，从头结点开始，他们的值是1，2，3，4，5，6.这个链表倒数第三个结点是值为4的结点。

方法 快慢指针

先让快指针向前遍历（n-1）个结点，然后慢指针再开始遍历链表。 n是问题倒数的数值
这里的两个指针速度相同，只是快指针早出发一会。
当快指针遍历到结尾时，慢指针刚好遍历到指定的倒数位置。

• 问题已理解

public ListNode kthNodeFromEnd(ListNode head,int kthNode){
        if(kthNode <= 0 || head == null) return null;
        ListNode pTemp = head,pKthNode = null;

        for(int count = 1;count < kthNode;count++){
            if(pTemp != null){
                pTemp = pTemp.next;
            }
        }
        while (pTemp != null){
            if (pKthNode == null){
                pKthNode = head;  //慢指针开始从头遍历
            }else{
                pKthNode = pKthNode.next; //慢指针继续遍历
            }
            pTemp = pTemp.next;
        }
        if(pKthNode != null){  
            return pKthNode;  //找到了对应结点
        }
        return null;
    }