排序算法（冒泡、选择、快速、归并）python

排序算法是计算机科学中用于对一组数据进行有序排列的基本操作，常见的排序算法有冒泡排序、选择排序、快速排序和归并排序。在 Python 中，这些算法可以通过内置函数 `sorted()` 或者自定义函数来实现。以下是简单介绍：

1. **冒泡排序 (Bubble Sort)**: 冒泡排序是一种简单的比较型排序算法，它的基本思想是重复地遍历待排序的序列，每次比较相邻的两个元素，如果它们的顺序错误就把它们交换过来。Python 示例：

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

2. **选择排序 (Selection Sort)**: 选择排序每次从未排序的部分找到最小（或最大）的元素，并将其放到已排序部分的末尾。Python 实现：

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

3. **快速排序 (Quick Sort)**: 快速排序是一种分治算法，通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，然后分别对这两部分记录继续进行排序，直到整个序列有序。Python 示例（使用 Hoare 变换）：

   def quick_sort(arr, low, high):
       if low < high:
           pivot_index = partition(arr, low, high)
           quick_sort(arr, low, pivot_index - 1)
           quick_sort(arr, pivot_index + 1, high)
   def partition(arr, low, high):
       pivot = arr[high]
       i = low - 1
       for j in range(low, high):
           if arr[j] <= pivot:
               i += 1
               arr[i], arr[j] = arr[j], arr[i]
       arr[i+1], arr[high] = arr[high], arr[i+1]
       return i + 1

4. **归并排序 (Merge Sort)**: 归并排序也是一种分治算法，它将待排序的序列分为两半，分别排序，然后合并。Python 示例：

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

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

如果你想深入了解这些排序算法的工作原理、性能以及适用场景，可以继续提问哦。