判斷回文鏈表

本文轉載自查看原文 2020-02-17 11:41 1222 高頻面試系列

我們之前有兩篇文章寫了回文串和回文序列相關的問題。

尋找回文串的核心思想是從中心向兩端擴展：

string palindrome(string& s, int l, int r) {
    // 防止索引越界
    while (l >= 0 && r < s.size()
            && s[l] == s[r]) {
        // 向兩邊展開
        l--; r++;
    }
    // 返回以 s[l] 和 s[r] 為中心的最長回文串
    return s.substr(l + 1, r - l - 1);
}

因為回文串長度可能為奇數也可能是偶數，長度為奇數時只存在一個中心點，而長度為偶數時存在兩個中心點，所以上面這個函數需要傳入l和r。

而判斷一個字符串是不是回文串就簡單很多，不需要考慮奇偶情況，只需要「雙指針技巧」，從兩端向中間逼近即可：

bool isPalindrome(string s) {
    int left = 0, right = s.length - 1;
    while (left < right) {
        if (s[left] != s[right])
            return false;
        left++; right--;
    }
    return true;
}

以上代碼很好理解吧，因為回文串是對稱的，所以正着讀和倒着讀應該是一樣的，這一特點是解決回文串問題的關鍵。

下面擴展這一最簡單的情況，來解決：如何判斷一個「單鏈表」是不是回文。

一、判斷回文單鏈表

輸入一個單鏈表的頭結點，判斷這個鏈表中的數字是不是回文：

/**
 * 單鏈表節點的定義：
 * public class ListNode {
 *     int val;
 *     ListNode next;
 * }
 */

boolean isPalindrome(ListNode head);

輸入: 1->2->null
輸出: false

輸入: 1->2->2->1->null
輸出: true

這道題的關鍵在於，單鏈表無法倒着遍歷，無法使用雙指針技巧。那么最簡單的辦法就是，把原始鏈表反轉存入一條新的鏈表，然后比較這兩條鏈表是否相同。關於如何反轉鏈表，可以參見前文「遞歸操作鏈表」。

其實，借助二叉樹后序遍歷的思路，不需要顯式反轉原始鏈表也可以倒序遍歷鏈表，下面來具體聊聊。

對於二叉樹的幾種遍歷方式，我們再熟悉不過了：

void traverse(TreeNode root) {
    // 前序遍歷代碼
    traverse(root.left);
    // 中序遍歷代碼
    traverse(root.right);
    // 后序遍歷代碼
}

在「學習數據結構的框架思維」中說過，鏈表兼具遞歸結構，樹結構不過是鏈表的衍生。那么，鏈表其實也可以有前序遍歷和后序遍歷：

void traverse(ListNode head) {
    // 前序遍歷代碼
    traverse(head.next);
    // 后序遍歷代碼
}

這個框架有什么指導意義呢？如果我想正序打印鏈表中的val值，可以在前序遍歷位置寫代碼；反之，如果想倒序遍歷鏈表，就可以在后序遍歷位置操作：

/* 倒序打印單鏈表中的元素值 */
void traverse(ListNode head) {
    if (head == null) return;
    traverse(head.next);
    // 后序遍歷代碼
    print(head.val);
}

說到這了，其實可以稍作修改，模仿雙指針實現回文判斷的功能：

// 左側指針
ListNode left;

boolean isPalindrome(ListNode head) {
    left = head;
    return traverse(head);
}

boolean traverse(ListNode right) {
    if (right == null) return true;
    boolean res = traverse(right.next);
    // 后序遍歷代碼
    res = res && (right.val == left.val);
    left = left.next;
    return res;
}

這么做的核心邏輯是什么呢？實際上就是把鏈表節點放入一個棧，然后再拿出來，這時候元素順序就是反的，只不過我們利用的是遞歸函數的堆棧而已。

當然，無論造一條反轉鏈表還是利用后續遍歷，算法的時間和空間復雜度都是 O(N)。下面我們想想，能不能不用額外的空間，解決這個問題呢？

二、優化空間復雜度

更好的思路是這樣的：

1、先通過「雙指針技巧」中的快慢指針來找到鏈表的中點：

ListNode slow, fast;
slow = fast = head;
while (fast != null && fast.next != null) {
    slow = slow.next;
    fast = fast.next.next;
}
// slow 指針現在指向鏈表中點

2、如果fast指針沒有指向null，說明鏈表長度為奇數，slow還要再前進一步：

if (fast != null)
    slow = slow.next;

3、從slow開始反轉后面的鏈表，現在就可以開始比較回文串了：

ListNode left = head;
ListNode right = reverse(slow);

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

至此，把上面 3 段代碼合在一起就高效地解決這個問題了，其中reverse函數很容易實現：

ListNode reverse(ListNode head) {
    ListNode pre = null, cur = head;
    while (cur != null) {
        ListNode next = cur.next;
        cur.next = pre;
        pre = cur;
        cur = next;
    }
    return pre;
}