Leetcode 之链表问题 （一）

1. Merge k sorted lists

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

//Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.
ListNode *merge2Lists(ListNode *head1, ListNode *head2){
        ListNode *head = new ListNode(INT_MIN);
        ListNode *pre = head;
        while(head1 != NULL && head2 != NULL){
            if(head1->val <= head2->val){
                pre->next = head1;
                head1 = head1->next;
            }else{
                pre->next = head2;
                head2 = head2->next;
            }
            pre = pre->next;
        }
        if(head1 != NULL){
            pre->next = head1;
        }
        if(head2 != NULL){
            pre->next = head2;
        }
        pre = head->next;
        delete head;
        return pre;
    }
ListNode *mergeKLists(vector<ListNode *> &lists) {
        if(lists.size() == 0) return NULL;
        ListNode *p = lists[0];
        for(int i=1; i<lists.size(); i++){
            p = merge2Lists(p, lists[i]);
        }
        return p;
    }

2. 

Swap Nodes in Pairs

 

Given a linked list, swap every two adjacent nodes and return its head.

For example,
Given 1->2->3->4, you should return the list as 2->1->4->3.

Your algorithm should use only constant space. You may not modify the values in the list, only nodes itself can be changed.

递归解法

ListNode *swapPairs(ListNode *head) {
       if(head == NULL || head->next == NULL)
        return head;
    ListNode *newPair = head->next->next;
    ListNode *newHead = head->next;
    head->next->next = head;
    head->next = swapPairs(newPair);
    return newHead; 
    }