Python快速排序的两种代码实现

最近面试中有遇到要求手写快速排序，在这里总结一下，也希望能帮助到其他有需要的朋友！

第一种：

#快速排序
def quicksort(nums, left, right):
  if left >= right:
    return
  mid = partition(nums, left, right)
  quicksort(nums, left, mid - 1)
  quicksort(nums, mid + 1, right)

def partition(nums, left, right):
  i = left
  j = right
  tmp = nums[left]
  while i < j:
    while i < j and nums[j] >= tmp:
      j -= 1
    while i < j and nums[i] <= tmp:
      i += 1
    if i < j:
      nums[i], nums[j] = nums[j], nums[i]
  nums[left], nums[i] = nums[i], nums[left]
  return i


# 示例
nums = [17, 3, 6, 8, 10, 1, 2, 1, 4, 7, 9]
quicksort(nums, 0, len(nums) - 1)
print(nums)  # 输出: [1, 1, 2, 3, 4, 6, 7, 8, 9, 10, 17]

第二种：

#快速排序
def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[0]
    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 quicksort(left) + middle + quicksort(right)

# 示例
arr = [17, 3, 6, 8, 10, 1, 2, 1, 4, 7, 9]
sorted_arr = quicksort(arr)
print(sorted_arr)  # 输出:[1, 1, 2, 3, 4, 6, 7, 8, 9, 10, 17]

时间复杂度：

        最优的时间复杂度：O(nlogn)，每一次取到的元素都刚好平分整个数组；

        最差的时间复杂度：O(n^2)，每一次取到的元素就是数组中最小/最大的，同冒泡排序；

        平均时间复杂度：O(nlogn)。

 空间复杂度：每次递归须使用栈

        最好的空间复杂度为：O(logn)，每一次取到的元素都刚好平分整个数组；

        最差的空间复杂度为：O(n) ，每一次取到的元素就是数组中最小/最大的，同冒泡排序。