golang quick_sort

Posted 2021-05-24

# 递归实现
def quick_sort(arr: list) -> list:
    if len(arr) <= 1:
        # 基线条件
        return arr
    else:
        # 递归条件
        mid = len(arr) // 2
        pivot = arr[mid]
        # less = [i for i in arr[1:] if i <= pivot]
        # greater = [i for i in arr[1:] if i > pivot]

        less = []
        greater = []
        for i in (arr[:mid] + arr[mid+1:]):
            if i <= pivot:
                less.append(i)
            else:
                greater.append(i)
    return quick_sort(less) + [pivot] + quick_sort(greater)


def quick_sort2(arr: list) -> list:
     # 如果使用 第0个元素作为基准点，在数组本身有序的情况下， less 数组始终为空，会导致栈的高度为 N
     # 每次执行循环两次筛选，会导致每层复杂度为2N 大 O表达式计算时会将常数忽略
    if len(arr) <= 1:
        return arr
    return quick_sort2([i for i in arr[1:] if i <= arr[0]]) + [arr[0]] + quick_sort2(
        [i for i in arr[1:] if i > arr[0]])


if __name__ == '__main__':
    print(quick_sort([6, 3, 14, 56, 3, 13, 1]))

package main

import (
    "fmt"
    "math/rand"
)

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

func quickSort(a []int) {
    if len(a) < 2 {
        return
    }

    left, right := 0, len(a)-1

    pivot := rand.Int() % len(a)

    a[pivot], a[right] = a[right], a[pivot]

    for i := range a {
        if a[i] < a[right] {
            a[left], a[i] = a[i], a[left]
            left++
        }
    }

    a[left], a[right] = a[right], a[left]

    quickSort(a[:left])
    quickSort(a[left+1:])
}

def quick_sort(array, left, right):
    if left >= right:
        return
    low = left
    high = right
    key = array[low]
    while left < right:
        while left < right and array[right] > key:
            right -= 1
        array[left] = array[right]
        while left < right and array[left] <= key:
            left += 1
        array[right] = array[left]
    array[right] = key
    quick_sort(array, low, left - 1)
    quick_sort(array, left + 1, high)


if __name__ == '__main__':
    l = [47, 5, 3, 5, 6, 87, -7, 2]
    quick_sort(l, 0, len(l) - 1)
    print(l)

package main

import "fmt"

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

// 递归实现
func quickSort(arr []int) []int {
    if len(arr) <= 1 {
        return arr
    } else {
        mid := len(arr) / 2
        pivot := arr[mid]
        less := make([]int, 0)
        greater := make([]int, 0)
        for _, v := range append(arr[:mid], arr[mid+1:]...) {
            if v <= pivot {
                less = append(less, v)
            } else {
                greater = append(greater, v)
            }
        }
        return append(append(quickSort(less), pivot ), quickSort(greater)...)
    }
}

Quick_sort快速排序

快速排序（交换排序）

按照之前学过的冒泡排序，我们知道它的时间复杂度达到了O(n的2次方)；那如果是对1亿个数字进行排序，则这个冒泡排序法需要1千万秒，达到115天之久，那么有没有更加快一点的排序呢?那就先来了解一下这个与冒泡类似的交换排序吧！

• 假设现在对“6、1、2、7、9、3、4、5、10、8”这10个数字排序。
• 首先在这个序列中找到一个数作为基准数（可不要被这个名词吓到，这就是用来参照的一个数，待会呢，你就知道它是用来干嘛的了）

首先我们需要在数列中选择一个基准数，我们一般会选择中间的一个数或者头尾的数，这里直接选择第 1 个数 6 作为基准数，接着把比 6 小的数字移动到左边，把比 6大的数字移动到右边，对于相等的数字不做移动。

快速排序的操作是这样的：从数据的两端开始探测，首先从数列的右边开始往左边找到一个小于6的数，再从右往左找一个大于6的数然后交换他们（切记一定先是从右往左找）直到二者相遇时，回归基数。
代码描述如下：

/***********************************************************
*版权所有：(C) 2021.6.10  烽火编程（第八方面军） 
* 
*文件名称：quick_sotr 
*内容摘要：排序算法 
*当前版本：1——1 
*文件作者：牛鹏 
*完成日期：2021.6.10
*
*修改记录：暂无 
***********************************************************/
#include <stdio.h>
#include <stdlib.h>
int Quick_Sort(int a[],int left,int right){
	int i,j,t,temp;
	if(left>right){
		return;
	}
	temp = a[left];//temp存放的就是基准数 
	i = left;
	j = right;
	while(i!=j){
		//顺序很重要，要先从右往左找,(找小) 
		while(a[j]>=temp && i<j){
			j--;
		}
		//在从左往右找，(找大) 
		while(a[i]<=temp && i<j){
			i++;
		}
		//在两个下标未遇之前，交换两个数在数组中的位置  
		if(i<j){
			t = a[i];
			a[i] = a[j];
			a[j] = t; 
		} 
	}
	//最终将基数归位
	a[left] = a[i];
	a[i] = temp;
	Quick_Sort(a,left,i-1);//继续处理左边部分 ，递归过程 
	Quick_Sort(a,i+1,right);//继续处理右边部分，递归过程 
} 
int main() {
	int a[] = {6,1,2,7,9,3,4,5,10,8};
	int i;
	for(i=0;i<10;i++){
		printf("%d ",a[i]);
	}
	Quick_Sort(a,0,9);
	printf("\\n排序后↓：\\n"); 
	for(i=0;i<10;i++){
		printf("%d ",a[i]);
	}
	return 0;
}