快速排序

什么是快速排序

快速排序是一种基于比较的排序算法，它的基本思想是：选择一个基准数，将序列中小于基准数的元素放在左边，大于基准数的元素放在右边，然后递归地对左右两个子序列进行同样的操作，直到序列有序为止。由于快速排序采用了分治的思想，因此它的平均时间复杂度为O(nlogn)，是常用的排序算法之一

用Python实现

def quickSort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[0]  # 选择第一个元素作为基准数
    left = [x for x in arr[1:] if x < pivot]  # 小于基准数的元素放在左边
    right = [x for x in arr[1:] if x >= pivot]  # 大于等于基准数的元素放在右边
    return quickSort(left) + [pivot] + quickSort(right)  # 递归地对左右两个子序列进行同样的操作

# 示例
arr = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
print(quickSort(arr))  # [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

 

在这个示例中，我们定义了一个名为quickSort的函数，它接收一个列表作为输入，并返回排好序的列表。在函数内部，我们首先判断列表的长度是否小于等于1，如果是，则直接返回该列表，因为只有一个元素或没有元素的列表已经是有序的了

接着，我们选择列表中的第一个元素作为基准数pivot，然后用列表推导式分别提取出小于基准数和大于等于基准数的元素，并分别存放在左右两个子列表left和right中

最后，我们递归地对左右两个子列表进行同样的操作，并将它们与基准数pivot合并起来。这个合并操作可以用+运算符实现，它将两个列表连接成一个新的列表

 

用go实现

package main

import "fmt"

func quickSort(arr []int) []int {
    if len(arr) <= 1 {
        return arr
    }
    pivot := arr[0]  // 选择第一个元素作为基准数
    var left, right []int
    for _, x := range arr[1:] {
        if x < pivot {
            left = append(left, x)  // 小于基准数的元素放在左边
        } else {
            right = append(right, x)  // 大于等于基准数的元素放在右边
        }
    }
    left = quickSort(left)  // 递归地对左右两个子序列进行同样的操作
    right = quickSort(right)
    return append(append(left, pivot), right...)  // 将左右两个子序列和基准数合并起来
}

func main() {
    arr := []int{3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5}
    fmt.Println(quickSort(arr))  // [1 1 2 3 3 4 5 5 5 6 9]
}

在这个示例中，我们定义了一个名为quickSort的函数，它接收一个整型切片作为输入，并返回排好序的整型切片。在函数内部，我们首先判断切片的长度是否小于等于1，如果是，则直接返回该切片，因为只有一个元素或没有元素的切片已经是有序的了

接着，我们选择切片中的第一个元素作为基准数pivot，然后使用for循环遍历切片中的剩余元素，将小于基准数的元素存放在left切片中，将大于等于基准数的元素存放在right切片中

最后，我们递归地对左右两个子切片进行同样的操作，并将它们与基准数pivot合并起来。这个合并操作可以使用append函数和...运算符实现，它将左右两个切片和基准数连接成一个新的切片

 

用js实现

function quickSort(arr) {
    if (arr.length <= 1) {
        return arr;
    }
    const pivot = arr[0];  // 选择第一个元素作为基准数
    const left = [];
    const right = [];
    for (let i = 1; i < arr.length; i++) {
        if (arr[i] < pivot) {
            left.push(arr[i]);  // 小于基准数的元素放在左边
        } else {
            right.push(arr[i]);  // 大于等于基准数的元素放在右边
        }
    }
    return quickSort(left).concat(pivot, quickSort(right));  // 将左右两个子数组和基准数合并起来
}

const arr = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
console.log(quickSort(arr));  // [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

在这个示例中，我们定义了一个名为quickSort的函数，它接收一个整型数组作为输入，并返回排好序的整型数组。在函数内部，我们首先判断数组的长度是否小于等于1，如果是，则直接返回该数组，因为只有一个元素或没有元素的数组已经是有序的了

接着，我们选择数组中的第一个元素作为基准数pivot，然后使用for循环遍历数组中的剩余元素，将小于基准数的元素存放在left数组中，将大于等于基准数的元素存放在right数组中

最后，我们递归地对左右两个子数组进行同样的操作，并将它们与基准数pivot合并起来。这个合并操作可以使用concat函数实现，它将左右两个数组和基准数连接成一个新的数组

 

用ts实现

function quickSort(arr: number[]): number[] {
  if (arr.length <= 1) {
    return arr;
  }
  const pivot = arr[0]; // 选择第一个元素作为基准数
  const left: number[] = [];
  const right: number[] = [];
  for (let i = 1; i < arr.length; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i]); // 小于基准数的元素放在左边
    } else {
      right.push(arr[i]); // 大于等于基准数的元素放在右边
    }
  }
  return [...quickSort(left), pivot, ...quickSort(right)]; // 将左右两个子数组和基准数合并起来
}

const arr: number[] = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
console.log(quickSort(arr)); // [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

在这个示例中，我们使用TypeScript来定义了函数的输入和输出类型。输入的参数arr是一个整型数组，返回值也是一个整型数组

在函数内部，我们使用let关键字声明了一个变量i，并使用for循环遍历数组中的剩余元素。我们使用if语句将小于基准数的元素存放在left数组中，将大于等于基准数的元素存放在right数组中

最后，我们使用扩展运算符...将左右两个子数组和基准数连接成一个新的数组，并使用return语句返回这个数组

注意：需要在tsconfig.json文件中设置"target": “es6”，才可以使用扩展运算符