Leetcode 23 合并K个升序链表

题目描述

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */

题解1(优先队列——纵向比较)

class Solution {
public:
    struct Status {
        int val;
        ListNode *ptr;
        // 对优先队列处理（内部排序）
        // 相当于纵向比较：
        // p1[1,2,3] 
        // p2[5,6,7]
        // p3[4,8,9]
        // 队列：[p1, p3, p2]
        // 第一轮 f = p1;
        // 因此第二轮开始前要把t = p1->next放进去
        // 更新队列：[t, p3, p2]
        
		// 优先级定义（a<b:a优先级<b优先级：大根堆里b排在a前）
		// 所以   b值<a值 
        bool operator < (const Status &rhs) const {
            return val > rhs.val;
        }
    };
//原型：template<class T, class Container = std::vector<T>, class Compare = std::less<typename Container::value_type>> class priority_queue;
    priority_queue <Status> q;

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        for (auto node: lists) {
        // 把各个链表首节点放到队列里
        // 队列自动排好了，但是保存的是Status类型
            if (node) q.push({node->val, node});
        }
        ListNode head, *tail = &head;
        while (!q.empty()) {
            auto f = q.top(); 
            q.pop();
            // 把队列首指针提出来即可（第一列排好序了）
            tail->next = f.ptr; 
            tail = tail->next;
            // 把首指针对应的链表的下一个结点放入队列
            if (f.ptr->next) q.push({f.ptr->next->val, f.ptr->next});
        }
        return head.next;
    }
};
//-----------------------------也可以只修改comp：
struct comp {
     bool operator()(ListNode* a, ListNode* b) {
     	return a->val > b->val;
    }
};
	priority_queue<ListNode*, vector<ListNode*>, comp> q; 
	// 等同于 priority_queue<ListNode*, comp> q; 
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        for (auto node: lists) {
        // 因为有排序（需要访问指针val值） 不能把nullptr插进去！！！！！
            if (node) q.push(node);
        }
        ListNode* head = new ListNode();
        ListNode* tail = head;
        // 一般size()会更快，可以查一下为什么（cy）
        while (!q.empty()) {
            ListNode* node = q.top();
            q.pop();
            tail->next = node; 
            tail = tail->next;
            // 把下个节点放进去
            if (node->next) q.push(node->next);
        }
        return head->next;
    }

题解2(循环合并：横向比较)

class Solution {
public:
//两个两个合并    
    ListNode* mergetwo(ListNode* l1, ListNode* l2){
        ListNode* dummy = new ListNode, *head;
        head = dummy;
        while(l1 && l2){
            if(l1->val <= l2->val){
                dummy->next = l1;
                l1 = l1->next;
            }else{
                dummy->next = l2;
                l2 = l2->next;
            }
            dummy = dummy->next;
        }
        dummy->next = l1 ? l1 : l2;
        return head->next;
    }
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        int sizes = lists.size();
        if(! sizes) return 0;
        for(int i = 0; i < sizes-1; i++){
            auto l = mergetwo(lists[i], lists[i+1]);
            //及时更新
            lists[i+1] = l;    
        }
        return lists[sizes-1];
        
    }
};

// 不改变lists
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode *l2){
        ListNode* dummynode = new ListNode(0);
        ListNode* p = dummynode;
        dummynode->next = p;

        while(l1 || l2){
            if(l1){
                if(l2 && l1->val <= l2->val){
                    p->next = l1;
                    p = p->next;
                    l1 = l1->next;
                    continue;
                }
                if(! l2){
                    p->next = l1;
                    break;
                }
            }
            if(l2){
                if(l1 && l2->val < l1->val){
                    p->next = l2;
                    p = p->next;
                    l2 = l2->next;
                    continue;
                }
                if(! l1){
                    p->next = l2;
                    break;
                }
            }
        }
        return dummynode->next;
    }
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        int s = lists.size();
        // 特判
        if( !s ) return nullptr;
  
        ListNode* p = nullptr;
        for(int i = 0; i < s; i++){
            // 合并2个有序链表
            // 空链表不用合并
            if(! lists[i]) continue;
            p = mergeTwoLists(p, lists[i]);   
        }
        return p;
    }
};

题解3(分治 / 二分)

class Solution {
public:
	//方法同 第21题 （快速默写）
    ListNode* mergeTwoLists(ListNode *a, ListNode *b) {
        if ((!a) || (!b)) return a ? a : b;

        ListNode head;
        ListNode* tail = &head;
        ListNode *aPtr = a, *bPtr = b;

        while (aPtr && bPtr) {
            if (aPtr->val < bPtr->val) {
                tail->next = aPtr; 
                aPtr = aPtr->next;
            } else {
                tail->next = bPtr; 
                bPtr = bPtr->next;
            }
            tail = tail->next;
        }
        tail->next = (aPtr ? aPtr : bPtr);
        return head.next;
    }
	//递归
    ListNode* merge(vector <ListNode*> &lists, int l, int r) {
        //e.g.5个元素：左侧递归：0 0, 1 1; p01, 2 2 ->p012 || 右侧递归：3 3, 4 4->p34
        // final : p012 merge p34 ->p01234
        if (l == r) return lists[l];
        
        int mid = (l + r) >> 1;
    	// 递归理解！
        return mergeTwoLists(merge(lists, l, mid), merge(lists, mid + 1, r));
    }

    ListNode* mergeKLists(vector<ListNode*>& lists) {
        // 下标
        // 含r版
        return merge(lists, 0, lists.size() - 1);
    }
};