LeetCode in Kotlin

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:

Input: head = [1,2,3,4]

Output: [1,4,2,3]

Example 2:

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 * 104].
• 1 <= Node.val <= 1000

Solution

import com_github_leetcode.ListNode

/*
 * Example:
 * var li = ListNode(5)
 * var v = li.`val`
 * Definition for singly-linked list.
 * class ListNode(var `val`: Int) {
 *     var next: ListNode? = null
 * }
 */
class Solution {
    private var forward: ListNode? = null
    fun reorderList(head: ListNode?) {
        forward = head
        dfs(head)
    }

    private fun dfs(node: ListNode?) {
        if (node != null) {
            dfs(node.next)
            if (forward != null) {
                val 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
            }
        }
    }
}

This site is open source. Improve this page.