算法练习(8)-判断单链表是否回文链表

在一些文学作品中，大家想必接触过回文诗，比如：“雾窗寒对遥天暮，暮天遥对寒窗雾”或“垂帘画阁画帘垂”，即：正着念反着念完全一样。回文单链表跟这个类似，比如:

0-1-2-1-0或0-1-1-0，很容易发现规律：可以找到一个对称轴，将链表分为前后二段，并且前后对折起来，完全重合。

为了方便，先定义单链表结构，以及一些工具类：

public class LinkNode {
    public int val;
    public LinkNode next;

    public LinkNode(int val, LinkNode next) {
        this.val = val;
        this.next = next;
    }

    public LinkNode(int val) {
        this.val = val;
    }
}

/**
 * @author yjmyzz@126.com
 * @blog http://yjmyzz.cnblogs.com 菩提树下的杨过
 */
public class LinkNodeUtils {

    /**
     * 打印单链表
     *
     * @param head
     */
    public static void print(LinkNode head) {
        if (head == null) {
            return;
        }
        while (head != null) {
            System.out.print(head.val + (head.next != null ? " -> " : "\n"));
            head = head.next;
        }
    }

    /**
     * 将数组填充到单链表
     *
     * @param arr
     * @return
     */
    public static LinkNode build(int[] arr) {
        if (arr == null || arr.length <= 0) {
            return null;
        }
        LinkNode head = new LinkNode(arr[0]);
        LinkNode curr = head;
        for (int i = 1; i < arr.length; i++) {
            LinkNode next = new LinkNode(arr[i]);
            curr.next = next;
            curr = next;
        }
        return head;
    }
}

 

解法1：利用stack翻转，然后逐一对比

代码如下：

    public static boolean isPalindromic(LinkNode head) {
        if (head == null || head.next == null) {
            return true;
        }
        LinkNode h = head;
        Stack<Integer> stack = new Stack<>();
        while (head != null) {
            stack.push(head.val);
            head = head.next;
        }
        head = h;
        while (head != null) {
            if (stack.pop() != head.val) {
                return false;
            }
            head = head.next;
        }
        return true;
    }

思路很简单：将所有元素逐一压入栈，由于堆栈先进后出，这样相当于把链表反向，然后跟原链表逐一对比，即：正向与反向，检查所有元素是否重合。

测试：

    public static void main(String[] args) {
        LinkNode h1 = LinkNodeUtils.build(new int[]{0});
        LinkNode h2_1 = LinkNodeUtils.build(new int[]{0, 0});
        LinkNode h2_2 = LinkNodeUtils.build(new int[]{0, 1});
        LinkNode h3_1 = LinkNodeUtils.build(new int[]{0, 1, 0});
        LinkNode h3_2 = LinkNodeUtils.build(new int[]{0, 1, 1});
        LinkNode h4_1 = LinkNodeUtils.build(new int[]{0, 1, 1, 0});
        LinkNode h4_2 = LinkNodeUtils.build(new int[]{0, 1, 2, 3});
        LinkNode h4_3 = LinkNodeUtils.build(new int[]{0, 1, 2, 0});
        LinkNode h5_1 = LinkNodeUtils.build(new int[]{0, 1, 2, 1, 0});
        LinkNode h5_2 = LinkNodeUtils.build(new int[]{0, 1, 2, 3, 0});
        LinkNode h6_1 = LinkNodeUtils.build(new int[]{0, 1, 2, 2, 1, 0});
        LinkNode h6_2 = LinkNodeUtils.build(new int[]{0, 1, 2, 3, 4, 5});

        System.out.printf("\n" + isPalindromic(h1) + " \t ");
        LinkNodeUtils.print(h1);

        System.out.printf("\n" + isPalindromic(h2_1) + " \t ");
        LinkNodeUtils.print(h2_1);
        System.out.printf("\n" + isPalindromic(h2_2) + " \t ");
        LinkNodeUtils.print(h2_2);

        System.out.printf("\n" + isPalindromic(h3_1) + " \t ");
        LinkNodeUtils.print(h3_1);
        System.out.printf("\n" + isPalindromic(h3_2) + " \t ");
        LinkNodeUtils.print(h3_2);

        System.out.printf("\n" + isPalindromic(h4_1) + " \t ");
        LinkNodeUtils.print(h4_1);
        System.out.printf("\n" + isPalindromic(h4_2) + " \t ");
        LinkNodeUtils.print(h4_2);
        System.out.printf("\n" + isPalindromic(h4_3) + " \t ");
        LinkNodeUtils.print(h4_3);

        System.out.printf("\n" + isPalindromic(h5_1) + " \t ");
        LinkNodeUtils.print(h5_1);
        System.out.printf("\n" + isPalindromic(h5_2) + " \t ");
        LinkNodeUtils.print(h5_2);

        System.out.printf("\n" + isPalindromic(h6_1) + " \t ");
        LinkNodeUtils.print(h6_1);
        System.out.printf("\n" + isPalindromic(h6_2) + " \t ");
        LinkNodeUtils.print(h6_2);
    }

输出：

true 	 0

true 	 0 -> 0

false 	 0 -> 1

true 	 0 -> 1 -> 0

false 	 0 -> 1 -> 1

true 	 0 -> 1 -> 1 -> 0

false 	 0 -> 1 -> 2 -> 3

false 	 0 -> 1 -> 2 -> 0

true 	 0 -> 1 -> 2 -> 1 -> 0

false 	 0 -> 1 -> 2 -> 3 -> 0

true 	 0 -> 1 -> 2 -> 2 -> 1 -> 0

false 	 0 -> 1 -> 2 -> 3 -> 4 -> 5

 

解法2：转换成数组，首尾对比

既然能用堆栈，也能使用数组，如下图：

相对解法1，将链表转换成数组后，利用回文的特点，折半检查，循环次数能降一半，比解法1稍微快一点。

    public static boolean isPalindromic2(LinkNode head) {
        if (head == null || head.next == null) {
            return true;
        }
        List<Integer> list = new ArrayList<>();
        while (head != null) {
            list.add(head.val);
            head = head.next;
        }
        for (int i = 0; i < list.size() / 2; i++) {
            if (!list.get(i).equals(list.get(list.size() - 1 - i))) {
                return false;
            }
        }
        return true;
    }

 

解法3：前半段压入栈，然后跟下半段对比

前面的2种解法，额外空间复杂度都是O(N)，但仔细想一下，既然是回文，前一半跟后一半是一样的，只需要将一半的元素压栈，再跟另一半对比就能知道结果，这样额外空间能省一半。

那么问题来了，怎么能正好将一半的元素压入堆栈？可以使用经典快慢指针，如上图，快指针1次走2步，慢指针1次走1步，这样fast走到尾时，slow指针刚好走到中间位置（或中间位置的前1个）

public static boolean isPalindromic3(LinkNode head) {
        if (head == null || head.next == null) {
            return true;
        }
        //2个元素的快速判断
        if (head.next.next == null) {
            return head.val == head.next.val;
        }
        LinkNode slow = head;
        LinkNode fast = head;
        Stack<Integer> stack = new Stack<>();
        while (fast.next != null) {
            if (fast.next.next != null) {
                stack.push(slow.val);
                fast = fast.next.next;
                slow = slow.next;
            } else {
                //fast在倒数第2个，不够向前跳2步的特殊处理
                stack.push(slow.val);
                break;
            }
        }
        //此时，slow要么在中点，要么在中间的前1个位置，再向前走1步，到达下半段的第1个位置
        slow = slow.next;
        while (slow != null) {
            if (slow.val != stack.pop()) {
                return false;
            }
            slow = slow.next;
        }
        return true;
    }

在借助额外空间的解法中，解法3是最好的版本。 

 

解法4：后半段翻转，跟前半段对比，对比结束再将后半段还原

前面的解法，都需要借助额外的存储空间，如果链表元素非常多（比如：几千万个），就算只要1半，占用的空间也不少。能否实现额外空间复杂度O(1)，也就是常数项，同时时间复杂度仍然在O(N)水平？

仔细想想，回文结构，前半段链表元素跟后半段是对称的。即：如果把后半段翻转过来，就跟前半段一样了。所以，只要把后半段单独拿出来，反转后再跟前半段对比，如果每个元素都一样，就是回文。不过要注意：这样会破坏原链表，所以在检查结束后，记得将后半段再翻转回来，跟前半段续接上，还原整个链表。

    static LinkNode middleNode(LinkNode head) {
        LinkNode slow = head;
        LinkNode fast = head;
        while (fast.next != null && fast.next.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }

    static LinkNode reverseList(LinkNode head) {
        LinkNode newHead = null;
        while (head != null) {
            LinkNode next = head.next;
            head.next = newHead;
            newHead = head;
            head = next;
        }
        return newHead;
    }

    public static boolean isPalindromic4(LinkNode head) {
        if (head == null || head.next == null) {
            //空链表或单个元素,也视为回文(相当于对称轴是自己)
            return true;
        }
        //2个元素的快速判断
        if (head.next.next == null) {
            return head.val == head.next.val;
        }
        LinkNode mid = middleNode(head);
        //后半段翻转
        LinkNode h2 = reverseList(mid.next);
        //保存下来,用于后面恢复
        LinkNode newH2 = h2;
        boolean isPalindromic = true;
        while (h2 != null) {
            if (h2.val != head.val) {
                isPalindromic = false;
                break;
            }
            h2 = h2.next;
            head = head.next;
        }
        //后半段翻转回来,跟前面的接上
        mid.next = reverseList(newH2);
        return isPalindromic;
    }

 如果在面试过程中大家遇到这道题，能把这4种解法依次演进，给面试官讲清楚，相信一定会给面试官司留下好印象