LeetCode精選TOP面試題160.相交鏈表

題目描述

編寫一個程序，找到兩個單鏈表相交的起始節點。返回值是ListNode類型。

示例 1：

輸入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], 
	 skipA = 2, skipB = 3
輸出：Reference of the node with value = 8
輸入解釋：相交節點的值爲 8 （注意，如果兩個列表相交則不能爲 0）。
		從各自的表頭開始算起，鏈表 A 爲 [4,1,8,4,5]，鏈表 B 爲 [5,0,1,8,4,5]。
		在 A 中，相交節點前有 2 個節點；在 B 中，相交節點前有 3 個節點。

示例 2：

輸入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], 
	 skipA = 3, skipB = 1
輸出：Reference of the node with value = 2
輸入解釋：相交節點的值爲 2 （注意，如果兩個列表相交則不能爲 0）。
		從各自的表頭開始算起，鏈表 A 爲 [0,9,1,2,4]，鏈表 B 爲 [3,2,4]。
		在 A 中，相交節點前有 3 個節點；在 B 中，相交節點前有 1 個節點。

示例 3：

輸入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
輸出：null
輸入解釋：從各自的表頭開始算起，鏈表 A 爲 [2,6,4]，鏈表 B 爲 [1,5]。
		由於這兩個鏈表不相交，所以 intersectVal 必須爲 0，
		而 skipA 和 skipB 可以是任意值。
解釋：這兩個鏈表不相交，因此返回 null。

要求：

• 如果兩個鏈表沒有交點，返回 null.
• 在返回結果後，兩個鏈表仍須保持原有的結構。
• 可假定整個鏈表結構中沒有循環。
• 程序儘量滿足 O(n) 時間複雜度，且僅用 O(1) 內存。

解題思路

• 分別遍歷兩個鏈表，統計兩個鏈表各自的長度lenA和lenB；
• 先對較長的鏈表進行遍歷，向前遍歷 | lenA - lenB | 次；
• 然後利用while循環同時遍歷兩個鏈表：
  + 如果遍歷過程中找到兩個鏈表的結點完全相等，那麼返回這個結點；
  + 如果遍歷結束依然沒有返回某個結點，那麼就說明這兩個鏈表不相交，返回null。

時間複雜度 O(m + n)
空間複雜度 O(1)

代碼實現（Java）

package it160.getIntersectionNode;

import sun.nio.cs.ext.MacArabic;

/**
 * @author : flower48237
 * @2020/3/27 9:52
 * @title : LeetCode精選TOP面試題160.相交鏈表
 */
/**
 * 輸入示例
 * 8
 *   [4,1,8,4,5]
 * [5,0,1,8,4,5]
 * 2
 * 3
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        int lenA = 0, lenB = 0; // 用來記錄兩個鏈表的長度
        ListNode p = headA;		
        while (p != null){
            lenA ++;			// 得到鏈表A的長度
            p = p.next;
        }
        p = headB;				
        while (p != null){
            lenB++;				// 得到鏈表B的長度
            p = p.next;
        }
        if (lenA < lenB){		// B 更長
            for (int i = 0; i < lenB - lenA; i ++){
            	// 先對長的鏈表B遍歷 lenB - lenA 次
                headB = headB.next;
            }
            while (headA != null && headB != null){
                if (headA == headB){
                	// 找到兩個鏈表中完全相同的結點並返回
                    return headA;
                }
                headA = headA.next;
                headB = headB.next;
            }
        }else {					// A 更長 或者 A 與 B 等長
            for (int i = 0; i < lenA - lenB; i ++){
            	// 先對長的鏈表B遍歷 lenA - lenB 次
                headA = headA.next;
            }
            while (headA != null && headB != null){
                if (headA == headB){
                	// 找到兩個鏈表中完全相同的結點並返回
                    return headA;
                }
                headA = headA.next;
                headB = headB.next;
            }
        }
        return null; // 不想交
    }
}