LeetCode 328. Odd Even Linked List (list of elements gathered on odd and even)

The meaning of problems: Given a list, a list element according to parity aggregation node odd positions in front of the node position behind the even.

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

analysis:

Act One: recursion.

(1) first recursive oddEvenList (head -> next -> next), the list in this case 2 -> 1 -> (recurse result: 3-> 6-> 7-> 5-> 4)

(2) 2 is inserted into the (odd bit recurse result of a first position) in front of 3, 5 1 is inserted into the front of the (first recursive results even bit position)

The disadvantage of this method, this requires each recursive chain length, over time complexity affirmative O (n), and is not recommended

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* oddEvenList(ListNode* head) {
        if(head == NULL || head -> next == NULL || head -> next -> next == NULL) return head;
        ListNode *tmp = head;
        int len ​​= 0;
        while(tmp){
            tmp = tmp -> next;
            ++ only;
        }
        ListNode *suf1 = head -> next;
        ListNode *suf2 = oddEvenList(head -> next -> next);
        head -> next = suf2;
        if(len % 2 == 0){
            as = (len - 2) / 2-1;
        }
        else{
            as = (len - 2) / 2;
        }
        tmp = suf2;
        while(len--){
            tmp = tmp -> next;
        }
        suf1 -> next = tmp -> next;
        tmp -> next = suf1;
        return head;
    }
};

Method two: odd bit even odd bit, even bit even even bit, then the beginning and end of chain even bit odd bit list.

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* oddEvenList(ListNode* head) {
        if(head == NULL) return NULL;
        ListNode* odd = head;
        ListNode* even = head -> next;
        ListNode* evenhead = head -> next;
        while(even && even -> next){
            odd -> next = odd -> next -> next;
            odd = odd -> next;
            even -> next = even -> next -> next;
            even = even -> next;
        }
        odd -> next = evenhead;
        return head;
    }
};