主流排序算法

  1. 冒泡排序(Bubble Sort):

    • 基本思想:通过比较相邻元素的大小,不断交换相邻元素的位置,使得较大的元素逐渐"浮"到数组的最后。
    • 时间复杂度:O(n^2)。
  2. 选择排序(Selection Sort):

    • 基本思想:每一次从未排序的部分中选择最小的元素,将其放在已排序部分的末尾。
    • 时间复杂度:O(n^2)。
  3. 插入排序(Insertion Sort):

    • 基本思想:将数组分为已排序和未排序两部分,每次从未排序部分选择一个元素插入到已排序部分的合适位置。
    • 时间复杂度:O(n^2)。
  4. 快速排序(Quick Sort):

    • 基本思想:通过选择一个基准元素,将数组划分为左右两部分,左边的元素都小于基准,右边的元素都大于基准,然后递归地对左右两部分进行排序。
    • 时间复杂度:平均情况下为O(n log n)。
  5. 归并排序(Merge Sort):

    • 基本思想:将数组分成两个部分,分别对这两个部分进行排序,然后合并这两个有序的部分。
    • 时间复杂度:始终为O(n log n),但需要额外的空间。
  6. 堆排序(Heap Sort):

    • 基本思想:利用堆的数据结构,将数组看作一个二叉堆,然后利用堆的性质进行排序。
    • 时间复杂度:O(n log n)。
  7. 计数排序(Counting Sort):

    • 基本思想:对每一个输入元素x,确定小于x的元素个数,从而确定x在输出序列中的位置。
    • 时间复杂度:O(n + k),其中k是最大元素的范围。
  8. 基数排序(Radix Sort):

    • 基本思想:从低位到高位,对输入元素进行多次排序,每次都是根据某一位上的数值进行排序。
    • 时间复杂度:O(d * (n + k)),其中d是最大数字的位数,k是进制。

简单代码示例:

  1. 冒泡排序(Bubble Sort):
python 复制代码
def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]

# 示例
arr = [64, 34, 25, 12, 22, 11, 90]
bubble_sort(arr)
print("冒泡排序结果:", arr)
  1. 选择排序(Selection Sort):
python 复制代码
def selection_sort(arr):
    n = len(arr)
    for i in range(n):
        min_index = i
        for j in range(i+1, n):
            if arr[j] < arr[min_index]:
                min_index = j
        arr[i], arr[min_index] = arr[min_index], arr[i]

# 示例
arr = [64, 25, 12, 22, 11]
selection_sort(arr)
print("选择排序结果:", arr)
  1. 插入排序(Insertion Sort):
python 复制代码
def insertion_sort(arr):
    for i in range(1, len(arr)):
        key = arr[i]
        j = i - 1
        while j >= 0 and key < arr[j]:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key

# 示例
arr = [12, 11, 13, 5, 6]
insertion_sort(arr)
print("插入排序结果:", arr)
  1. 快速排序(Quick Sort):
python 复制代码
def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quick_sort(left) + middle + quick_sort(right)

# 示例
arr = [3, 6, 8, 10, 1, 2, 1]
result = quick_sort(arr)
print("快速排序结果:", result)
  1. 堆排序(Heap Sort):
python 复制代码
def heapify(arr, n, i):
    largest = i
    left = 2 * i + 1
    right = 2 * i + 2

    if left < n and arr[i] < arr[left]:
        largest = left

    if right < n and arr[largest] < arr[right]:
        largest = right

    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        heapify(arr, n, largest)

def heap_sort(arr):
    n = len(arr)

    for i in range(n // 2 - 1, -1, -1):
        heapify(arr, n, i)

    for i in range(n - 1, 0, -1):
        arr[i], arr[0] = arr[0], arr[i]
        heapify(arr, i, 0)

# 示例
arr = [12, 11, 13, 5, 6, 7]
heap_sort(arr)
print("堆排序结果:", arr)
  1. 归并排序(Merge Sort):
python 复制代码
def merge_sort(arr):
    if len(arr) > 1:
        mid = len(arr) // 2
        left_half = arr[:mid]
        right_half = arr[mid:]

        merge_sort(left_half)
        merge_sort(right_half)

        i = j = k = 0

        while i < len(left_half) and j < len(right_half):
            if left_half[i] < right_half[j]:
                arr[k] = left_half[i]
                i += 1
            else:
                arr[k] = right_half[j]
                j += 1
            k += 1

        while i < len(left_half):
            arr[k] = left_half[i]
            i += 1
            k += 1

        while j < len(right_half):
            arr[k] = right_half[j]
            j += 1
            k += 1

# 示例
arr = [12, 11, 13, 5, 6, 7]
merge_sort(arr)
print("归并排序结果:", arr)
  1. 计数排序(Counting Sort):
python 复制代码
def counting_sort(arr):
    output = [0] * len(arr)
    count = [0] * (max(arr) + 1)

    for i in arr:
        count[i] += 1

    for i in range(1, len(count)):
        count[i] += count[i - 1]

    i = len(arr) - 1
    while i >= 0:
        output[count[arr[i]] - 1] = arr[i]
        count[arr[i]] -= 1
        i -= 1

    for i in range(len(arr)):
        arr[i] = output[i]

# 示例
arr = [4, 2, 2, 8, 3, 3, 1]
counting_sort(arr)
print("计数排序结果:", arr)
  1. 基数排序(Radix Sort):
python 复制代码
def counting_sort_for_radix(arr, exp):
    n = len(arr)
    output = [0] * n
    count = [0] * 10

    for i in range(n):
        index = arr[i] // exp
        count[index % 10] += 1

    for i in range(1, 10):
        count[i] += count[i - 1]

    i = n - 1
    while i >= 0:
        index = arr[i] // exp
        output[count[index % 10] - 1] = arr[i]
        count[index % 10] -= 1
        i -= 1

    for i in range(n):
        arr[i] = output[i]

def radix_sort(arr):
    max_num = max(arr)

    exp = 1
    while max_num // exp > 0:
        counting_sort_for_radix(arr, exp)
        exp *= 10

# 示例
arr = [170, 45, 75, 90, 802, 24, 2, 66]
radix_sort(arr)
print("基数排序结果:", arr)
相关推荐
qqxhb3 分钟前
零基础数据结构与算法——第四章:基础算法-排序(中)
数据结构·算法·排序算法·归并·快排·堆排
木叶丸1 小时前
编程开发中,那些你必须掌握的基本概念
前端·数据结构·编程语言
Y1nhl1 小时前
力扣_链表_python版本
开发语言·python·算法·leetcode·链表·职场和发展
qq_401700412 小时前
C语言中位运算以及获取低8位和高8位、高低位合并
c语言·开发语言·算法
CoovallyAIHub2 小时前
YOLO模型优化全攻略:从“准”到“快”,全靠这些招!
深度学习·算法·计算机视觉
闻缺陷则喜何志丹2 小时前
【BFS】 P10864 [HBCPC2024] Genshin Impact Startup Forbidden II|普及+
c++·算法·宽度优先·洛谷
MicroTech20252 小时前
微算法科技(NASDAQ: MLGO)探索Grover量子搜索算法,利用量子叠加和干涉原理,实现在无序数据库中快速定位目标信息的效果。
数据库·科技·算法
今天背单词了吗9803 小时前
算法学习笔记:8.Bellman-Ford 算法——从原理到实战,涵盖 LeetCode 与考研 408 例题
java·开发语言·后端·算法·最短路径问题
手握风云-3 小时前
优选算法的链脉之韵:链表专题
数据结构·算法·链表
Coding小公仔3 小时前
LeetCode 151. 反转字符串中的单词
开发语言·c++·算法