程序猿修仙之路--算法之快速排序到底有多快

时间 2019-11-08

标签程序修仙之路算法快速排序到底多快繁體版

原文原文链接

分治思想

关于排序，江湖盛传有一种分治思想,能大幅度提升排序心法的性能。所谓分治，即：化大为小，分而治之。达到治小而治大的成效。多年来基于分治思想衍生出多种排序心法，然万变不离其宗！golang

虽然江湖上算法内功繁多，可是好的算法小编认为必须符合如下几个条件，方能真正提升习练者实力。算法

时间复杂度（运行时间）

在算法时间复杂度维度，咱们主要对比较和交换的次数作对比，其余不交换元素的算法，主要会以访问数组的次数的维度作对比。c#

其实有不少修炼者对于算法的时间复杂度有点模糊，分不清什么所谓的 O(n),O(nlogn),O(logn)...等，也许下图对一些人有一些更直观的认识。数组

空间复杂度（额外的内存使用）

排序算法的额外内存开销和运行时间同等重要。就算一个算法时间复杂度比较优秀，空间复杂度很是差，使用的额外内存很是大，菜菜认为它也算不上一个优秀的算法。bash

结果的正确性

这个指标是菜菜本身加上的，我始终认为一个优秀的算法最终获得的结果必须是正确的。就算一个算法拥有很是优秀的时间和空间复杂度，可是结果不正确，致使修炼者经脉逆转，走火入魔，又有什么意义呢？app

原理

基本思想：选取一个元素做为分割点，经过遍历把小于分割点的元素放到分割点左边，把大于分割点的元素放到分割点元素右边。而后再按此方法对两部分数据分别排序，以此类推，直到分割的数组大小为1。整个排序过程能够递归进行，以此达到整个数据变成有序序列。dom

过程

实现快速排序的方式有不少，其中以相似指针移动方式最为常见，为何最多见呢？由于它的空间复杂度为O（1），也就是说是原地排序。性能

咱们从待排序的记录序列中选取一个记录(一般第一个)做为基准元素(称为key)key=arr[left]，而后设置两个变量，left指向数列的最左部，right指向数据的最右部。
key首先与arr[right]进行比较，若是arr[right]<key，则arr[left]=arr[right]将这个比key小的数放到左边去，若是arr[right]>key则咱们只须要将right--，right--以后，再拿arr[right]与key进行比较，直到arr[right]<key交换元素为止。
若是右边存在arr[right]<key的状况，将arr[left]=arr[right]，接下来，将转向left端，拿arr[left ]与key进行比较，若是arr[left]>key,则将arr[right]=arr[left]，若是arr[left]<key，则只须要将left++,而后再进行arr[left]与key的比较。
而后再移动right重复上述步骤
最后获得 {23 58 13 10 57 62} 65 {106 78 95 85}，再对左子数列与右子数列进行一样的操做。最终获得一个有序的数列。

{23 58 13 10 57 62} 65 {106 78   95 85}
{10 13} 23 {58 57 62} 65 {85 78 95} 106
10 13 23 57 58 62 65 78 85 95 106
复制代码

性能特色

关于复杂度相关O（n）等公式，我这里须要强调一点,公式表明的是算法的复杂度增加的趋势，而不是具体计算复杂度的公式。好比：O（n²）和O（n）相比较，只是说明 O(n²)增加的趋势要比o(n)快，并非说明O(n²)的算法比O(n)的算法所用时间必定就要多。ui

时间复杂度

快速排序平均时间复杂度为O(nlogn),最好状况下为O(nlogn)，最坏状况下O(n²)spa

空间复杂度

基于以上例子来实现的快排，空间复杂度为O(1),也就是原地排序。

稳定性

举个例子：待排序数组:int a[] ={1, 2, 2, 3, 4, 5, 6};

在快速排序的随机选择比较子(即pivot)阶段：若选择a[2]（即数组中的第二个2）为比较子，，而把大于等于比较子的数均放置在大数数组中，则a[1]（即数组中的第一个2）会到pivot的右边，那么数组中的两个2非原序（这就是“不稳定”）。若选择a[1]为比较子，而把小于等于比较子的数均放置在小数数组中，则数组中的两个2顺序也非原序。可见快速排序不是稳定的排序。

改进

经过以上分析各位侠士是否可以分析出来快速排序有哪些地方存在瑕疵呢？

切分不平衡：也就是说咱们选取的切分元素距离数组中间值的元素位置很远，极端状况下会是数组最大或最小的元素，这就致使了划分出来的大数组会被划分为不少次。针对此状况，咱们能够取数组多个元素来平衡这种状况，例如：咱们能够随机选取三个或者五个元素，取其中间值的元素做为分割元素。
小数组：当快速排序切分为比较小的数组时候，也会利用递归调用本身。在这种小数组的状况下，其实一些基础排序算法反而比快速排序要快。当数组比较小的时候不妨尝试一下切换到插入排序。具体多小是小呢？通常5-15吧，仅供参考。
重复元素：在咱们实际应用中常常会遇到重复元素比较多的状况，按照快排的思想，相同元素是会被频繁移动和划分的，其实这彻底没有必要。咱们该怎么办呢？咱们能够把数组切换为三部分：大于-等于-小于三部分数组，这样等于的那部分数组就能够避免移动了，不过落地的代码复杂度要高不少，有兴趣的同窗能够实现一下。

使用场景

当一个数组大小为中型以上的数量级时，菜菜认为可使用快速排序，而且伴随着数组的持续增大，快速排序的性能趋于平均运行时间。至于多大的数组为中型，通常认为50+ 吧，仅供参考。
当一个数组为无序而且重复元素很少时候，也适合快速排序。为何提出重复元素这个点呢？由于若是重复元素过多，原本重复元素是无需排序的，可是快速排序仍是要划分为更多的子数组来比较，这个时候也许插入排序更适合。

试炼一发吧

c# 武器版

static void Main(string[] args)
        {
            List<int> data = new List<int>();
            for (int i = 0; i < 11; i++)
            {

                data.Add(new Random(Guid.NewGuid().GetHashCode()).Next(1, 100));
            }
            //打印原始数组值
            Console.WriteLine($"原始数据： {string.Join(",", data)}");
            quickSort(data, 0, data.Count - 1);
            //打印排序后的数组
            Console.WriteLine($"排序数据： {string.Join(",", data)}");
            Console.Read();
        }
        public static void quickSort(List <int> source, int left, int right)
        {
            int pivot = 0;
            if (left < right)
            {
                pivot = partition(source, left, right);
                quickSort(source, left, pivot - 1);
                quickSort(source, pivot + 1, right);
            }
        }
        //对一个数组/列表按照第一个元素 分组排序，返回排序以后key所在的位置索引
        private static int partition(List<int> source, int left, int right)
        {
            int key = source[left];
            while (left < right)
            {
                //从右边筛选 大于选取的值的不动，小于key的交换位置
                while (left < right && source[right] >= key)
                {
                    right--;
                }
                source[left] = source[right];
                while (left < right && source[left] <= key)
                {
                    left++;
                }
                source[right] = source[left];
            }
            source[left] = key;
            return left;
        }
复制代码

golang 武器版

package main

import (
	"fmt"
	"math/rand"
)

func main() {
	var data []int
	for i := 0; i < 10; i++ {
		data = append(data, rand.Intn(100))
	}
	fmt.Println(data)
	quickSort(data[:], 0, len(data)-1)
	fmt.Println(data)
}
func quickSort(source []int, left int, right int) {
	var pivot = 0
	if left < right {
		pivot = partition(source, left, right)                                        
		quickSort(source, left, pivot-1)
		quickSort(source, pivot+1, right)
	}
}

func partition(source []int, left int, right int) int {
	var key = source[left]
	for left < right {
		for left < right && source[right] >= key {
			right--
		}
		source[left] = source[right]
		for left < right && source[left] <= key {
			left++
		}
		source[right] = source[left]
	}
	source[left] = key
	return left
}

复制代码

运行结果：

[81 87 47 59 81 18 25 40 56 0]
[0 18 25 40 47 56 59 81 81 87]
复制代码

添加关注，查看更精美版本，收获更多精彩