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 ...
@taglinkedlist
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 singlylinked 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/oddevenlinkedlist/ // 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 singlylinked 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