LeetCodeClassification ---- No.1 分治 --- 快速排序( 递归 )

快速排序

• 基准条件：
  只有一个值或者数组为空，不需要快速排序了。
  

• 递归条件
  左边放小于基准值的数组，然后对其进行快速排序 （使用递归实现）
  右边放大于基准值的数组，然后对其进行快速排序 （使用递归实现）

• 合
  将快排的数组按照从左到有排起来，实现数组的从小到大排序。

python

# 快速排序 

def quickSort(arr):
    if len(arr) < 2:
        return arr 
    else:
        base = arr[0]
        less = [i for i in arr[1:] if i <= base]
        greater = [i for i in arr[1:] if i > base]
        
        return quickSort(less) + [base] + quickSort(greater)

quickSort([1,3,2,1,4,15])

go

package main

import (
	"fmt"
)

// 自定义的函数
func get_less_greater_array(arr []int, base int) (lessArray []int, greaterArray []int) {
	base = arr[0]
	for i := 1; i < len(arr); i++ {
		if arr[i] <= base {
			lessArray = append(lessArray, arr[i])
		} else {
			greaterArray = append(greaterArray, arr[i])
		}
	}
	return lessArray, greaterArray
}

func quickSort_self(arr []int) (newArr_self []int) {

	if len(arr) < 2 {
		return arr
	} else {
		baseValue := arr[0]
		mid := make([]int, 0, 0)
		mid = append(mid, baseValue)
		less, greater := get_less_greater_array(arr, baseValue)
		lessArray := quickSort_self(less)
		greaterArray := quickSort_self(greater)
		newArr_self = append(append(lessArray, mid...), greaterArray...)
		return newArr_self
	}
}

// 网上找的: https://www.bilibili.com/read/cv7163983
func quickSort(arr []int) []int {

	if len(arr) < 2 {
		return arr
	} else {
		base := arr[0]
		low := make([]int, 0, 0)
		high := make([]int, 0, 0)
		mid := make([]int, 0, 0)
		mid = append(mid, base)
		for i := 1; i < len(arr); i++ {
			if arr[i] < base {
				low = append(low, arr[i])
			} else if arr[i] > base {
				high = append(high, arr[i])
			} else {
				mid = append(mid, arr[i])
			}
		}
		low, high = quickSort(low), quickSort(high)
		myarr := append(append(low, mid...), high...)
		return myarr
	}
}

func main() {

	arr := []int{1, 2, 2, 12, 1, 1, 4}
	newArr := quickSort(arr)
	fmt.Println("quickSort: ", newArr)

	newArr_self := quickSort_self(arr)
	fmt.Println("quickSort_self: ", newArr_self)
}

思考

自己在写的过程中，没有初始化数组的意识，如果使用初试话数组，就可以将自定义的函数简化掉，让程序变得简洁明了。

还有两个小知识点：

向数组中添加元素

拼接多个数组

go代码实现：

package main

import "fmt"

func main() {
	var arr = []int{111, 222, 333}
	var a = []int{1, 2, 4, 5, 6}
	// 使用 for 单次添加 element
	for _, v := range arr {
		a = append(a, v)
	}
	fmt.Println(a)

	// 使用 append(self, arr...) 完成全部数组的添加
	a = append(a, arr...)
	fmt.Println(a)
}