算法 | 排序 | 问题23

简介

本文主要介绍算法中的排序算法以及问题23，是一道经典的算法面试题目。

排序算法是计算机程序中最基本、最重要的算法之一，对于程序员来说是必备的基本功。排序可以使数据更加有序，从而提高程序的效率。

问题23是一道经典的Leetcode问题，考察了程序员的排序算法实现能力以及对于数组遍历的掌握程度。

本文将从排序算法的基本概念入手，逐渐深入探讨各种排序算法的特点、优缺点以及实现方法，最后详细介绍问题23的解题思路和代码实现。

排序算法

冒泡排序

冒泡排序是一种简单的排序算法。它重复遍历要排序的数列，一次比较两个元素大小，将大的元素交换到右侧，因此大的元素会逐渐从左侧移动到右侧。

代码实现如下:

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

插入排序

插入排序是一种简单直观的排序算法。它的工作原理类似于排序一手牌，将拍好的牌插入到已经排序好的牌的适当位置。

代码实现如下:

def insertion_sort(arr):
    n = len(arr)
    for i in range(1, n):
        j = i - 1
        key = arr[i]
        while j >= 0 and arr[j] > key:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key
    return arr

选择排序

选择排序是一种简单的排序算法。它的工作原理是每次找到未排序序列中的最小值，然后放到已经排序序列的末尾。

代码实现如下:

def selection_sort(arr):
    n = len(arr)
    for i in range(n-1):
        min_idx = i
        for j in range(i+1, n):
            if arr[min_idx] > arr[j]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]
    return arr

快速排序

快速排序是一种高效的排序算法，采用了分治法的思想。它的工作原理是通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字都小于另一部分记录的关键字。然后再按此方法对两部分记录进行排序，以达到整个序列有序的目的。

代码实现如下:

def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    else:
        pivot = arr[0]
        left = [x for x in arr[1:] if x < pivot]
        right = [x for x in arr[1:] if x >= pivot]
        return quick_sort(left) + [pivot] + quick_sort(right)

归并排序

归并排序是一种稳定的排序算法，采用了分治法的思想。它的工作原理是将待排序序列分成若干个子序列，分别排序的，在将已经排序号的子序列合并成一个有序序列。

代码实现如下:

def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)

def merge(left, right):
    res = []
    i = j = 0
    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            res.append(left[i])
            i += 1
        else:
            res.append(right[j])
            j += 1
    res += left[i:]
    res += right[j:]
    return res

问题23

题目描述：

将k个有序链表合并为一个有序链表

示例：

输入:
[
  1->4->5,
  1->3->4,
  2->6
]
输出: 1->1->2->3->4->4->5->6

思路

这道题是一个经典的合并有序数组的问题。我们可以采用优先队列，根据每个链表的头节点建立小根堆，每次弹出堆顶元素即可。

代码实现

import heapq

def mergeKLists(lists):
    """
    :type lists: List[ListNode]
    :rtype: ListNode
    """
    pq = []
    for i, node in enumerate(lists):
        if node:
            heapq.heappush(pq, (node.val, i, node))
            
    res = ListNode(0)
    p = res
    while pq:
        _, i, node = heapq.heappop(pq)
        p.next = node
        p = p.next
        if node.next:
            heapq.heappush(pq, (node.next.val, i, node.next))
    return res.next

结语

本文介绍了基本的排序算法，以及针对算法的实现方法和优缺点进行了分析。最后详细介绍了算法题问题23的解题思路和完整代码实现。希望能够帮助到算法初学者们。