g0101_0200.s0143_reorder_list.Solution Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation

Java-based LeetCode algorithm problem solutions, regularly updated

There is a newer version: 1.38

package g0101_0200.s0143_reorder_list;

// #Medium #Two_Pointers #Stack #Linked_List #Recursion #Data_Structure_II_Day_13_Linked_List
// #Programming_Skills_II_Day_14 #2022_06_24_Time_2_ms_(72.59%)_Space_55.1_MB_(5.83%)

import com_github_leetcode.ListNode;

/*
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
/**
 * 143 - Reorder List\.
 *
 * Medium
 *
 * You are given the head of a singly linked-list. The list can be represented as:
 *
 * L₀ → L₁ → … → L_{n - 1} → L_n 
 *
 * _Reorder the list to be on the following form:_
 *
 * L₀ → L_n → L₁ → L_{n - 1} → L₂ → L_{n - 2} → … 
 *
 * You may not modify the values in the list's nodes. Only nodes themselves may be changed.
 *
 * **Example 1:**
 *
 * ![](https://assets.leetcode.com/uploads/2021/03/04/reorder1linked-list.jpg)
 *
 * **Input:** head = [1,2,3,4]
 *
 * **Output:** [1,4,2,3] 
 *
 * **Example 2:**
 *
 * ![](https://assets.leetcode.com/uploads/2021/03/09/reorder2-linked-list.jpg)
 *
 * **Input:** head = [1,2,3,4,5]
 *
 * **Output:** [1,5,2,4,3] 
 *
 * **Constraints:**
 *
 * *   The number of nodes in the list is in the range [1, 5 * 10⁴].
 * *   `1 <= Node.val <= 1000`
**/
public class Solution {
    private ListNode forward;

    public void reorderList(ListNode head) {
        forward = head;
        dfs(head);
    }

    private void dfs(ListNode node) {
        if (node != null) {
            dfs(node.next);
            if (forward != null) {
                ListNode next = forward.next;
                // even case: forward.next coincide with node
                if (next == node) {
                    node.next = null;
                } else {
                    node.next = next;
                }
                forward.next = node;
                forward = node.next;
            }
            // odd case: forward coincide with node
            if (forward == node) {
                forward.next = null;
                forward = forward.next;
            }
        }
    }
}