Given a singly linked list L: L0→L1→…→Ln-1→Ln,
reorder it to: L0→Ln→L1→Ln-1→L2→Ln-2→…You must do this in-place without altering the nodes' values.

For example,
Given {1,2,3,4}, reorder it to {1,4,2,3}.

 1 public class Solution {
 2     public void reorderList(ListNode head) {
 3         if (head == null) return;
 4         ListNode dummy = new ListNode(-1);
 5         dummy.next = head;
 6         ListNode runner = dummy;
 7         ListNode walker = dummy;
 8         while (runner != null && runner.next != null) {
 9             runner = runner.next.next;
10             walker = walker.next;
11         }
12         ListNode head2 = walker.next;
13         walker.next = null;
14         head2 = reverse(head2);
15         runner = head2;
16         walker = head;
17         ListNode prev = dummy;
18         while (runner!=null && walker!=null) {
19             ListNode next = runner.next;
20             runner.next = walker.next;
21             walker.next = runner;
22             runner = next;
23             walker = walker.next.next;
24             prev = prev.next.next;
25         }
26         if (runner != null) {
27             prev.next = runner;
28         }
29     }
30
31     public ListNode reverse(ListNode header) {
32         if (header == null) return null;
33         ListNode dummy = new ListNode(-1);
34         dummy.next = header;
35         ListNode cur = header;
36         while (cur.next != null) {  //find the last non-null element of this list
37             cur = cur.next;
38         }
39         ListNode last = cur; // name the last non-null element as last
40         while (dummy.next != last) {
41             cur = dummy.next;
42             ListNode next = cur.next;
43             cur.next = last.next;
44             last.next = cur;
45             dummy.next = next;
46         }
47         return dummy.next;
48     }
49 }

 1 /**
 2  * Definition for singly-linked list.
 3  * class ListNode {
 4  *     int val;
 5  *     ListNode next;
 6  *     ListNode(int x) {
 7  *         val = x;
 8  *         next = null;
 9  *     }
10  * }
11  */
12 public class Solution {
13     public void reorderList(ListNode head) {
14         if (head == null || head.next == null) return;
15         ListNode dummy = new ListNode(-1);
16         dummy.next = head;
17         ListNode current = dummy;
18         ListNode runner = dummy;
19         while (runner.next != null && runner.next.next != null) {
20             current = current.next;
21             runner = runner.next.next;
22         }
23         ListNode half = current.next;
24         current.next = null;
25
26         /*reverse the second Linked List*/
27         if (runner.next != null) runner = runner.next; //make sure the runner pointer points to the end of the the second Linked List
28         ListNode dummy2 = new ListNode(-2);
29         dummy2.next = half;//create another dummy node whose next points to the head of the second Linked List
30         while (dummy2.next != runner) {
31             ListNode dnext = dummy2.next.next;
32             ListNode rnext = runner.next;
33             dummy2.next.next = rnext;
34             runner.next = dummy2.next;
35             dummy2.next = dnext;
36         }
37
38         /*merge the two Linked List together*/
39         ListNode header1 = dummy;
40         ListNode header2 = dummy2;
41         while (header1.next != null && header2.next != null) {
42             ListNode store = header1.next.next;
43             ListNode merge = new ListNode(header2.next.val);
44             header1.next.next = merge;
45             merge.next = store;
46             header1 = header1.next.next;
47             header2 = header2.next;
48         }
49         if (header2.next != null) {
50             header1.next = header2.next;
51         }
52     }
53 }

 1 private ListNode reverse(ListNode head)
 2 {
 3     ListNode pre = null;
 4     ListNode cur = head;
 5     while(cur!=null)
 6     {
 7         ListNode next = cur.next;
 8         cur.next = pre;
 9         pre = cur;
10         cur = next;
11     }
12     return pre;
13 }     

31     public ListNode reverse(ListNode header) {
32         if (header==null) return null;
33         ListNode prev = new ListNode(-1);
34         prev.next = header;
35         ListNode cur = prev;
36         ListNode node1 = header;
37         ListNode node2 = header.next;
38         ListNode end = header;
39         while (node2 != null) {
40             ListNode next = node2.next;
41             cur.next = node2;
42             node2.next = node1;
43             node1 = node2;
44             node2 = next;
45         }
46         end.next = null;
47         return prev.next;
48     }