Introduction Link to heading

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 ...

Solution Link to heading

Usually I write programs with 0 as a base index, so this solution a little bit non-standard, because starts from even number that I considering 0.

	/**
	 * Definition for singly-linked list.
	 * type ListNode struct {
	 *     Val int
	 *     Next *ListNode
	 * }
	 */
	func oddEvenList(head *ListNode) *ListNode {
	    even := head
	    if head != nil && head.Next != nil {
	        node := head.Next
	        oddHead, odd := node, node
	        i := 1
	        for node = node.Next; node != nil; node = node.Next {
	            if i % 2 == 0 {
	                odd.Next = node
	                odd = node
	            } else {
	                even.Next = node
	                even = node
	            }
	            i++
	        }
	        odd.Next = nil
	        even.Next = oddHead
	        return head
	    } else {
	        return even
	    }

	}
}

Let’s refactor code to remove odd and even in loop detection

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func oddEvenList(head *ListNode) *ListNode {
    even := head
    if even == nil {
        return nil
    }
    oddHead, odd := even.Next, even.Next
    for odd != nil && odd.Next != nil {
        even.Next = odd.Next
        even = odd.Next
        odd.Next = even.Next
        odd = even.Next
    }
    even.Next = oddHead
    return head
}