实现排序算法

可以使用各种不同的算法来实现排序，以下是几种常见的排序算法：

1. 冒泡排序（Bubble Sort）：通过不断交换相邻两个元素的位置，将最大的元素逐渐 “冒泡” 到最后的位置。

   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]
       return arr
   

2. 选择排序（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]
       return arr
   

3. 插入排序（Insertion Sort）：将未排序部分的元素一个一个地插入到已排序部分的正确位置。

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

4. 快速排序（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)
   

5. 归并排序（Merge Sort）：将数组分成两个部分，分别对两个部分进行递归排序，然后将排序好的两个部分合并成一个有序数组。

   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):
       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 += left[i:]
       result += right[j:]
       return result
   

以上是几种常见的排序算法，每种算法的时间复杂度和空间复杂度不同，可以根据具体需求选择合适的算法。