LeetCode-23. 合并K个排序链表

23. 合并K个排序链表 <<<< 题目传送门

• 题目描述

合并 k 个排序链表，返回合并后的排序链表。请分析和描述算法的复杂度。

示例:

输入:

[
  1->4->5,
  1->3->4,
  2->6
]

输出: 1->1->2->3->4->4->5->6

• 题解

额，这个想起来也不算难，读取所有链表节点的值，然后构造最小堆，一直取堆顶元素就能获得结果。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None


from heapq import heapify, heappop

class Solution:
    def mergeKLists(self, lists: List[ListNode]) -> ListNode:
        # 获取所有节点
        nodes = []
        for node in lists:
            while node:
                nodes.append(node.val)
                node = node.next
        # 由于报错，添加了获取后的节点值列表是否为空，如果是空，则直接返回
        if nodes == []:
            return None

        # 构造最小堆
        heapify(nodes)

        # 构造结果链表
        head = ListNode(heappop(nodes))
        cur_node = head
        while nodes:
            next_node = ListNode(heappop(nodes))
            cur_node.next = next_node
            cur_node = next_node
        return head

347. 前 K 个高频元素 <<<< 题目传送门

• 描述

  给定一个非空的整数数组，返回其中出现频率前 k 高的元素。

  示例 1:

  输入: nums = [1,1,1,2,2,3], k = 2

  输出: [1,2]

  示例 2:

  输入: nums = [1], k = 1

  输出: [1]

  说明：

  你可以假设给定的 k 总是合理的，且 1 ≤ k ≤ 数组中不相同的元素的个数。
  你的算法的时间复杂度必须优于 O(n log n) , n 是数组的大小。

• 题解

思路是比较清晰的，因为是用Python来解决。就跟闹着玩一样，用Counter统计出元素出现频率，用heapq处理一下就能解决。

和正常的操作比过于简单了。先建立映射，再维护前k大的一个堆。

# 耍赖的写法哈，不过确实香。O(∩_∩)O哈哈~
import heapq
from collections import Counter


class Solution:
    def topKFrequent(self, nums, k: int):
        counts = Counter(nums)
        # 这里的key需要传入的是func（函数哈）
        return heapq.nlargest(k, counts.keys(), key=counts.get)