Question

Formatted question description: https://leetcode.ca/all/328.html

 328	Odd Even Linked List

 Given a singly linked list, group all odd nodes together followed by the even nodes.
 Please note here we are talking about the node number and not the value in the nodes.

 You should try to do it in place.
 The program should run in O(1) space complexity and O(nodes) time complexity.

 Example 1:

 Input: 1->2->3->4->5->NULL
 Output: 1->3->5->2->4->NULL

 Example 2:

 Input: 2->1->3->5->6->4->7->NULL
 Output: 2->3->6->7->1->5->4->NULL

 Note:

 The relative order inside both the even and odd groups should remain as it was in the input.
 The first node is considered odd, the second node even and so on ...

 @tag-linkedlist

Algorithm

Two parity pointers are used to point to the starting position of the even node respectively, and a separate pointer even_head is needed to save the starting position of the even node.

Then point the odd node to the next one of the even node (it must be the odd node), and move this odd node one step later.

Then point the even node to the next odd node (it must be an even node), this even node is moved one step later, and so on until the end.

At this time, the linked list of the separated even node is connected after the linked list of the odd node.

Code

Java

public class Odd_Even_Linked_List {
    /**
     * Definition for singly-linked list.
     * public class ListNode {
     *     int val;
     *     ListNode next;
     *     ListNode(int x) { val = x; }
     * }
     */

    class Solution {
        public ListNode oddEvenList(ListNode head) {

            if (head == null) {
                return head;
            }

            // input head is odd head
            ListNode evenHeadDummy = new ListNode(0);

            ListNode oddPrev = head;
            ListNode evenPrev = evenHeadDummy;
            ListNode current = head.next;
            boolean isEven = true; // start from 2nd

            while (current != null) {

                if (isEven) {
                    evenPrev.next = current;
                    evenPrev = current;
                } else {
                    oddPrev.next = current;
                    oddPrev = current;
                }

                // flip
                isEven = !isEven;
                current = current.next;
            }

            // @note: cut last even->odd, or else loop
            evenPrev.next = null;

            // connect
            oddPrev.next = evenHeadDummy.next;

            return head;
        }
    }
}

// OJ: https://leetcode.com/problems/odd-even-linked-list/
// Time: O(N)
// Space: O(1)
class Solution {
public:
    ListNode* oddEvenList(ListNode* head) {
        ListNode evenHead, *evenTail = &evenHead, oddHead, *oddTail = &oddHead;
        for (bool odd = true; head; odd = !odd, head = head->next) {
            if (odd) {
                oddTail->next = head;
                oddTail = head;
            } else {
                evenTail->next = head;
                evenTail = head;
            }
        }
        oddTail->next = evenHead.next;
        evenTail->next = NULL;
        return oddHead.next;
    }
};

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
  def oddEvenList(self, head):
    """
    :type head: ListNode
    :rtype: ListNode
    """
    o = odd = ListNode(-1)
    e = even = ListNode(-1)
    p = head
    isOdd = True
    while p:
      if isOdd:
        o.next = p
        o = o.next
        isOdd = False
      else:
        e.next = p
        isOdd = True
        e = e.next
      p = p.next
    e.next = None
    o.next = even.next
    return odd.next

328 - Odd Even Linked List

Question

Algorithm

Code

All Problems

All Solutions