python-经典排序算法总结

1、冒泡排序 (Bubble Sort):

• 基本思想：通过不断交换相邻元素将最大的元素逐步移动到数组的末尾。

• 

• 时间复杂度：平均和最坏情况都是O(n^2)。

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

2、插入排序 (Insertion Sort):

• 基本思想：通过构建有序序列，逐个将元素插入到已排好序的部分。

• 

• 1.从第一个元素开始，该元素可以认为已经被排序
  2.取下一个元素A，从已排序的元素序列从后往前扫描
  3.如果该元素大于A，则将该元素移到下一位
  4.重复步骤3，直到找到已排序元素中小于等于A的元素
  5.tem插入到该元素的后面，如果已排序所有元素都大于A，则将A插入到下标为0的位置
  6.重复步骤2~5
   

• 时间复杂度：平均和最坏情况都是O(n^2)，最好情况是O(n)。

• 实现：

• 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
   

3、选择排序 (Selection Sort):

• 基本思想：通过不断选择未排序部分的最小元素，放到已排序部分的末尾。

• 

• 时间复杂度：平均、最坏和最好情况都是O(n^2)。

• 实现：

• 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]
   

4、归并排序 (Merge Sort):

• 基本思想：将数组递归地分成两半，对每一半进行排序，然后合并已排序的两半。

• 

• 时间复杂度：平均、最坏和最好情况都是O(n log n)。

• 实现：

• 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

5 、快速排序 (Quick Sort):

• 基本思想：通过选择一个基准元素，将数组分为两部分，左边的元素小于基准，右边的元素大于基准，然后对左右两部分递归地进行排序。

• 

• 时间复杂度：平均情况是O(n log n)，最坏情况是O(n^2)。

• 实现：

• 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)