Basic singly linked list operations including reversing and calculating length. The problem requires: 1->2->3->4 => 1->4->2->3, an interleaving operation. Given a singly linked list L: L0->L1->…->Ln-1->Ln, reorder it to: L0->Ln->L1->Ln-1->L2->Ln-2->…
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
class Solution {
public :
void reorderList ( ListNode * head ) {
int len = getLength ( head );
if ( len <= 2 ) return ;
int pos = len % 2 == 0 ? len / 2 : len / 2 + 1 ;
ListNode * headend = getListNode ( head , pos - 1 );
ListNode * head2 = getListNode ( head , pos );
headend -> next = NULL ;
head2 = reverseListNode ( head2 );
ListNode * headc = head ;
while ( head2 != NULL ) {
ListNode * headnext = head -> next ;
ListNode * head2next = head2 -> next ;
head -> next = head2 ;
head2 -> next = headnext ;
head = headnext ;
head2 = head2next ;
}
head = headc ;
}
private :
ListNode * reverseListNode ( ListNode * head ) {
ListNode * before = head ;
ListNode * now = head -> next ;
while ( now != NULL ) {
ListNode * next = now -> next ;
now -> next = before ;
before = now ;
now = next ;
}
head -> next = NULL ;
return before ;
}
int getLength ( ListNode * head ) {
int len = 0 ;
while ( head != NULL ) {
len ++ ;
head = head -> next ;
}
return len ;
}
ListNode * getListNode ( ListNode * head , int pos ) {
int i = 0 ;
while ( i < pos ) {
head = head -> next ;
i ++ ;
}
return head ;
}
};
Licensed under CC BY-NC-SA 4.0