链表（5）

一、判断一个链表是否为回文结构

给定一个链表，请判断该链表是否为回文结构。

回文是指该字符串正序逆序完全一致。

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    public boolean isPail (ListNode head) {
        if (head == null) return true;

        // 快慢指针找中点
        ListNode slow = head, fast = head;
        while (fast.next != null && fast.next.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }

        // 反转后半段
        ListNode pre = null;
        ListNode cur = slow.next;
        while (cur != null) {
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }

        // 比较
        while (pre != null) {
            if (pre.val != head.val) return false;
            pre = pre.next;
            head = head.next;
        }
        return true;
    }
}

运行结果

二、链表的奇偶重排

给定一个单链表，请设定一个函数，将链表的奇数位节点和偶数位节点分别放在一起，重排后输出。

注意是节点的编号而非节点的数值。

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param head ListNode类
     * @return ListNode类
     */
    public ListNode oddEvenList (ListNode head) {
        ListNode oddDummy = new ListNode(-1), evenDummy = new ListNode(-1);
        ListNode oddTail = oddDummy, evenTail = evenDummy;
        boolean isOdd = true;
        ListNode cur = head;
        while (cur != null) {
            if (isOdd) {
                oddTail.next = cur;
                oddTail = cur;
                cur = cur.next;
                oddTail.next = null;
            } else {
                evenTail.next = cur;
                evenTail = cur;
                cur = cur.next;
                evenTail.next = null;
            }
            isOdd = !isOdd;
        }
        oddTail.next = evenDummy.next;
        return oddDummy.next;
    }
}

运行结果

三、删除有序链表中重复的元素（1）

删除给出链表中的重复元素（链表中元素从小到大有序），使链表中的所有元素都只出现一次
例如：
给出的链表为1→1→2,返回1→2.
给出的链表为1→1→2→3→3,返回1→2→3.

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param head ListNode类
     * @return ListNode类
     */
    public ListNode deleteDuplicates (ListNode head) {
        if (head == null) return head;
        // 有序链表若有重复元素，则它们是相邻的
        // 我们从 head 出发，记作 cur
        // 若 cur 有下一个节点，我们进行如下的分类讨论：
        // Ⅰ cur.val == cur.next.val：cur.next 是重复元素，移除它。
        // Ⅱ cur.val != cur.next.val：cur.val 不存在重复元素，cur 后移一位
        ListNode cur = head;
        while (cur.next != null) {
            if (cur.val == cur.next.val) {
                cur.next = cur.next.next;
            } else {
                cur = cur.next;
            }
        }
        return head;
    }
}

运行结果

四、删除有序链表中重复的元素（2）

给出一个升序排序的链表，删除链表中的所有重复出现的元素，只保留原链表中只出现一次的元素。
例如：
给出的链表为1→2→3→3→4→4→5, 返回1→2→5.
给出的链表为1→1→1→2→3, 返回2→3.

数据范围：链表长度 0≤n≤10000，链表中的值满足 ∣val∣≤1000

要求：空间复杂度 O(n)，时间复杂度 O(n)

进阶：空间复杂度 O(1)，时间复杂度 O(n)

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param head ListNode类
     * @return ListNode类
     */
    public ListNode deleteDuplicates (ListNode head) {
        // head 处可能会被删除，因此需要引入 dummy 节点来简化处理
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        // 基于有序链表，重复元素相邻的特性，我们可以采取两两比较的方式找出值重复的元素
        // 我们从 dummy 出发，记作 cur
        // 然后两两比较其下一个节点和下下个节点的值（若都存在的话）
        // 若二者相等，说明当前值是重复的，因此将其全部删除。
        // 否则，cur.next.val 是不重复的，其作为下一组值的前驱节点。
        ListNode cur = dummy;
        while (cur.next != null && cur.next.next != null) {
            if (cur.next.val == cur.next.next.val) {
                int duplicatedVal = cur.next.val;
                while (cur.next != null && cur.next.val == duplicatedVal) {
                    cur.next = cur.next.next;
                }
            } else {
                cur = cur.next;
            }
        }
        return dummy.next;
    }
}

运行结果