LeetCode算法题-Palindrome Linked List(Java实现)

这是悦乐书的第196次更新,第202篇原创

01 看题和准备

今天介绍的是LeetCode算法题中Easy级别的第58题(顺位题号是234)。给出一个单链表,确定它是否是回文。例如:

输入:1-> 2

输出:false

输入:1-> 2-> 2-> 1

输出:true

本次解题使用的开发工具是eclipse,jdk使用的版本是1.8,环境是win7 64位系统,使用Java语言编写和测试。

02 第一种解法

获取原链表反转后的新链表,然后使用循环,依次比较两个链表的节点是否相等。反转链表可以借助之前一道反转单链表的题目,可以直接拿过来用。

public boolean isPalindrome(ListNode head) {
    if (head == null || head.next == null) {
        return true;
    }
    ListNode result = reverseList(head);
    while (head != null && result != null) {
        if (head.val != result.val) {
            return false;
        }
        head = head.next;
        result = result.next;
    }
    return true;
}

public ListNode reverseList(ListNode head) {
    if (head == null || head.next == null) {
        return head;
    }
    Stack<ListNode> stack = new Stack<>();
    while (head != null) {
        stack.push(head);
        head = head.next;
    }
    ListNode res = new ListNode(-1);
    ListNode temp = res;
    while (!stack.isEmpty()) {
        temp.next = new ListNode(stack.pop().val);
        temp = temp.next;
    }
    return res.next;
}

03 第二种解法

利用栈先进后去的特点,先将head的每个节点入栈,然后循环判断head的节点值和出栈的值是否相等,只要不相等即可返回false。

public boolean isPalindrome2(ListNode head) {
    if (head == null || head.next == null) {
        return true;
    }
    ListNode newHead = new ListNode(-1);
    newHead.next = head;
    Stack<Integer> stack = new Stack<>();
    while (newHead.next != null) {
        stack.push(newHead.next.val);
        newHead.next = newHead.next.next;
    }
    while (head != null && !stack.isEmpty()) {
        if (head.val != stack.pop()) {
            return false;
        }
        head = head.next;
    }
    return true;
}

04 第三种解法

先使用双指针同时遍历head节点,找到中间节点的位置,然后将剩下的部分进行反转,然后比较head和反转后的另一半节点值,如果不相等,则说明它不是回文链表。

此解法的时间复杂度是O(n),空间复杂度是O(1)。

public boolean isPalindrome3(ListNode head) {
    ListNode fast = head;
    ListNode slow = head;
    while (fast != null && fast.next != null) {
        fast = fast.next.next;
        slow = slow.next;
    }
    if (fast != null) {
        slow = slow.next;
    }
    slow = reverse(slow);
    fast = head;
    while (slow != null) {
        if (fast.val != slow.val) {
            return false;
        }
        fast = fast.next;
        slow = slow.next;
    }
    return true;
}

public ListNode reverse(ListNode head) {
    ListNode prev = null;
    while (head != null) {
        ListNode next = head.next;
        head.next = prev;
        prev = head;
        head = next;
    }
    return prev;
}

05 第四种解法

此解法是利用递归,先声明一个全局变量head1,然后将head1指向head,利用递归获取到head的最后一个节点,然后和head1的第一个节点开始比较,不相等就依次向上返回。如果相等,head1指向其下一个节点,然后和head的上一层节点相比,判断是否相等。

ListNode head1;

public boolean isPalindrome4(ListNode head) {
    if(head==null || head.next==null){
        return true;
    }
    head1=head;
    return palin(head);

}

private boolean palin(ListNode last) {
    if (last.next == null) {
        return last.val == head1.val;
    }
    boolean val = palin(last.next);
    if (!val) {
        return val;
    }
    head1 = head1.next;
    val = head1.val == last.val;
    return val;
}

06 小结

算法专题目前已连续日更超过一个月,算法题文章58+篇,公众号对话框回复【数据结构与算法】、【算法】、【数据结构】中的任一关键词,获取系列文章合集。

以上就是全部内容,如果大家有什么好的解法思路、建议或者其他问题,可以下方留言交流,点赞、留言、转发就是对我最大的回报和支持!

    原文作者:悦乐书
    原文地址: https://www.jianshu.com/p/9d95a8c3a2f6
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞