常见排序、查找算法的时间复杂度&空间复杂度&描述&示例

最新推荐文章于 2024-05-23 15:15:06 发布

健魏消食骗

最新推荐文章于 2024-05-23 15:15:06 发布

阅读量362

点赞数 1

分类专栏：算法文章标签：算法排序算法数据结构

本文链接：https://blog.csdn.net/qq_53217531/article/details/132673935

版权

算法专栏收录该内容

1 篇文章 0 订阅

订阅专栏

本文详细介绍了常见的排序算法（如冒泡、选择、插入、快速、归并、堆排序等）和查找算法（线性、二分、哈希表、二叉搜索树、AVL树）的时间复杂度、空间复杂度以及简单实现示例，帮助读者理解各种算法的工作原理和适用场景。

摘要由CSDN通过智能技术生成

常见的排序算法

下面是一些常见的排序算法的时间复杂度、空间复杂度、算法实现描述以及简单示例：

排序算法	平均情况时间复杂度	最坏情况时间复杂度	最好情况时间复杂度	空间复杂度	算法描述
冒泡排序 (Bubble Sort)	O(n^2)	O(n^2)	O(n)	O(1)	通过比较相邻元素并交换它们来排序，重复进行直到没有交换为止。
选择排序 (Selection Sort)	O(n^2)	O(n^2)	O(n^2)	O(1)	在未排序部分中选择最小元素并将其移动到已排序部分的末尾。
插入排序 (Insertion Sort)	O(n^2)	O(n^2)	O(n)	O(1)	逐个将元素插入到已排序部分的正确位置。
快速排序 (Quick Sort)	O(nlogn)	O(n^2)	O(nlogn)	平均情况O(logn)，最坏情况O(n)	选择一个基准元素，将数组分为两部分，递归对每部分进行排序。
归并排序 (Merge Sort)	O(nlogn)	O(nlogn)	O(nlogn)	O(n)	将数组分为两部分，递归排序并合并两个有序子数组。
堆排序 (Heap Sort)	O(nlogn)	O(nlogn)	O(nlogn)	O(1)	构建最大堆（或最小堆），依次取出堆顶元素并维护堆性质。
计数排序 (Counting Sort)	O(n+k)	O(n+k)	O(n+k)	O(k)	统计每个元素出现的次数，按顺序输出元素。
桶排序 (Bucket Sort)	O(n + n^2/k + k)	O(n^2)	O(n)	O(n + k)	将数据分散到多个桶中，对每个桶内数据排序，然后合并桶。
基数排序 (Radix Sort)	O(d*(n+b))	O(d*(n+b))	O(d*(n+b))	O(n+b)	按照数字的位数进行排序，依次排列。

注意：在上表中，n表示数组或数据结构的大小，logn表示以2为底的对数。

下面是每个算法的简单示例：

冒泡排序 (Bubble Sort)

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        swapped = False
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                swapped = True
        if not swapped:
            break

arr = [64, 34, 25, 12, 22, 11, 90]
bubble_sort(arr)
print("冒泡排序结果:", arr)

选择排序 (Selection Sort)

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

arr = [64, 25, 12, 22, 11]
selection_sort(arr)
print("选择排序结果:", arr)

插入排序 (Insertion Sort)

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 = [64, 34, 25, 12, 22, 11, 90]
insertion_sort(arr)
print("插入排序结果:", arr)

快速排序 (Quick Sort)

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 = [64, 25, 12, 22, 11]
result = quick_sort(arr)
print("快速排序结果:", result)

归并排序 (Merge Sort)

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

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

arr = [38, 27, 43, 3, 9, 82, 10]
result = merge_sort(arr)
print("归并排序结果:", result)

堆排序 (Heap Sort)



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)

def heapify(arr, n, i):
    largest = i
    left = 2 * i + 1
    right = 2 * i + 2
    if left < n and arr[left] > arr[largest]:
        largest = left
    if right < n and arr[right] > arr[largest]:
        largest = right
    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        heapify(arr, n, largest)

arr = [64, 25, 12, 22, 11]
heap_sort(arr)
print("堆排序结果:", arr)

计数排序 (Counting Sort)

def counting_sort(arr):
    max_val = max(arr)
    min_val = min(arr)
    range_of_elements = max_val - min_val + 1
    count_arr = [0] * range_of_elements
    output_arr = [0] * len(arr)

    for i in range(len(arr)):
        count_arr[arr[i] - min_val] += 1

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

    for i in range(len(arr) - 1, -1, -1):
        output_arr[count_arr[arr[i] - min_val] - 1] = arr[i]
        count_arr[arr[i] - min_val] -= 1

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

arr = [64, 25, 12, 22, 11]
counting_sort(arr)
print("计数排序结果:", arr)

桶排序 (Bucket Sort)

def bucket_sort(arr):
    max_val = max(arr)
    min_val = min(arr)
    bucket_range = (max_val - min_val) / len(arr)
    bucket_list = [[] for _ in range(len(arr) + 1)]

    for num in arr:
        index = int((num - min_val) / bucket_range)
        if index == len(arr):
            index -= 1
        bucket_list[index].append(num)

    sorted_arr = []
    for bucket in bucket_list:
        sorted_arr.extend(sorted(bucket))

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

arr = [64, 25, 12, 22, 11]
bucket_sort(arr)
print("桶排序结果:", arr)

基数排序 (Radix Sort)

def radix_sort(arr):
    max_num = max(arr)
    exp = 1
    while max_num // exp > 0:
        counting_sort_radix(arr, exp)
        exp *= 10

def counting_sort_radix(arr, exp):
    n = len(arr)
    output = [0] * n
    count = [0] * 10

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

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

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

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

arr = [170, 45, 75, 90, 802, 24, 2, 66]
radix_sort(arr)
print("基数排序结果:", arr)

请注意，这只是每个排序算法的简单示例，实际应用中可能需要根据具体情况进行优化。此外，上述示例中的排序算法都是针对整数的排序，对于其他类型的数据，需要适当修改比较函数。

常见的查找算法

以下是一些常见的查找算法的时间复杂度、空间复杂度、算法实现描述以及简单示例：

查找算法	最好情况时间复杂度	最坏情况时间复杂度	平均情况时间复杂度	空间复杂度	算法描述
线性查找 (Linear Search)	O(1)	O(n)	O(n)	O(1)	逐个检查数组中的元素，直到找到目标元素或遍历完整个数组。
二分查找 (Binary Search)	O(1)	O(logn)	O(logn)	O(1)	针对有序数组，在每次比较后将搜索范围缩小一半，直到找到目标元素或确定不存在。
哈希表查找 (Hash Table)	O(1)	O(n)	O(1)	O(n)（存储哈希表）	使用哈希函数将关键字映射到存储位置，通过索引直接访问元素。
二叉搜索树查找 (BST)	O(logn)	O(n)	O(logn)	O(n)（树的存储）	通过比较关键字，根据二叉搜索树的结构递归查找目标元素。
AVL树查找	O(logn)	O(logn)	O(logn)	O(n)（树的存储）	一种自平衡二叉搜索树，保持树的平衡，提高查找效率。

注意：在上表中，n表示数组或数据结构的大小，logn表示以2为底的对数。

下面是每个算法的简单示例：

线性查找 (Linear Search)

def linear_search(arr, target):
    for i in range(len(arr)):
        if arr[i] == target:
            return i
    return -1

arr = [10, 20, 30, 40, 50]
target = 30
result = linear_search(arr, target)
print("线性查找结果:", result)

二分查找 (Binary Search)

def binary_search(arr, target):
    left, right = 0, len(arr) - 1
    while left <= right:
        mid = left + (right - left) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

arr = [10, 20, 30, 40, 50]
target = 30
result = binary_search(arr, target)
print("二分查找结果:", result)

哈希表查找 (Hash Table)

class HashTable:
    def __init__(self):
        self.size = 10
        self.table = [None] * self.size

    def hash(self, key):
        return sum([ord(char) for char in key]) % self.size

    def insert(self, key, value):
        index = self.hash(key)
        self.table[index] = value

    def search(self, key):
        index = self.hash(key)
        return self.table[index]

hash_table = HashTable()
hash_table.insert("apple", 10)
hash_table.insert("banana", 20)
result = hash_table.search("apple")
print("哈希表查找结果:", result)

二叉搜索树查找 (BST)

class TreeNode:
    def __init__(self, key):
        self.left = None
        self.right = None
        self.val = key

def bst_search(root, target):
    if root is None or root.val == target:
        return root
    if root.val < target:
        return bst_search(root.right, target)
    return bst_search(root.left, target)

root = TreeNode(30)
root.left = TreeNode(20)
root.right = TreeNode(40)
root.left.left = TreeNode(10)
root.right.right = TreeNode(50)
target = 40
result = bst_search(root, target)
print("二叉搜索树查找结果:", result.val if result else None)

AVL树查找

class TreeNode:
    def __init__(self, key):
        self.left = None
        self.right = None
        self.val = key
        self.height = 1

def avl_search(root, target):
    if root is None or root.val == target:
        return root
    if root.val < target:
        return avl_search(root.right, target)
    return avl_search(root.left, target)

root = TreeNode(30)
root.left = TreeNode(20)
root.right = TreeNode(40)
root.left.left = TreeNode(10)
root.right.right = TreeNode(50)
target = 40
result = avl_search(root, target)
print("AVL树查找结果:", result.val if result else None)