快速排序

像是冒泡排序的升级版，也有着插入排序的影子，大多数情况下，效率最高

核心思想:分而治之,与二分查找法有点联系，像是一种东西的正反两用。

举个生活中的例子，就像切豆腐，一块豆腐切成两块，给两个人，原先一个人的工作量，相当于两个人完成，效率近似于一半(毕竟切开这个动作，再给两个人这都是浪费效率的)，然后两块豆腐再切开，最开始一个人的工作量，四个人共同完成，这就是快速排序为什么快。就像细胞分裂一样，这种速度是相当恐怖的，也可以想象下2的次幂
当然如果只是很小的一块豆腐，那这样来回分，反倒不如直接一个人切来的快，所以，快速排序的时间复杂度（效率）会随着数据量的增加，慢慢显露出其明显的优势,平均效率为O(nlogn)
而我们也可以看出，豆腐切开的点，也就是入刀点尤其重要，因为只有最中间的时候，才是最快的，如果从豆腐的最边缘切开，那无疑一个人，还是切那一块豆腐，而另一个人完全是摸鱼了

选择入刀点的方法:前人总结出来的比较优秀的一种方法，是开头，结尾，中间位置取三个数，然后求中位数

执行流程:quick方法,把第一次的实参传递给quickSort,并调用quickSort方法,quickSort,先调用median方法,取得中位数,然后依次执行完，再根据条件，是否继续递归,全部递归完,顺序就排好了

下面附上用js实现的代码:

<script>
    // 封装一个方法,使原型方法之间能互相调用,更方便
    function Arr() {
        this.array = []

        //往数组里添加元素
        Arr.prototype.insert = function (item) {
            this.array.push(item)
        }
        
        //把结果转换为字符串形式
        Arr.prototype.toString = function () {
            return this.array.join()
        }
    
        //两个数进行交换
        Arr.prototype.swap = function (m, n) {
            var temp = this.array[m]
            this.array[m] = this.array[n]
            this.array[n] = temp
        }

        // 选择入刀点
        Arr.prototype.median = function (left, right) {
            // 1.求出中间的位置,这里必须用向下取整,不然会造成无限递归
            var center = Math.floor((left + right) / 2)

            // 2.通过交换,把中位数放到中间的位置
            if (this.array[left] > this.array[center]) {
                this.swap(left, center)
            }
            if (this.array[center] > this.array[right]) {
                this.swap(center, right)
            }
            if (this.array[left] > this.array[center]) {
                this.swap(left, center)
            }

            // 3. 将center移动到right - 1的位置,这个时候能得出center一定比right位置的数小
            //再之后就是left和center之间的数依次和center比大小，然后最后把center放到一个正好的位置
            //左面的数全部比它小，右面的全部比它大
            this.swap(center, right - 1)

            // 4.返回入刀点
            return this.array[right - 1]
        }

        // 快速排序实现
        Arr.prototype.quick = function () {
            //第一次调用quickSort,并把实参传过去,之后就是quickSort递归了
            this.quickSort(0, this.array.length - 1)
        }

        Arr.prototype.quickSort = function (left, right) {
            // 0.递归结束条件
            if (left >= right) return

            // 1.获取枢纽
            var pivot = this.median(left, right)

            // 2.开始进行交换
            var i = left
            var j = right - 1
            while (true) { //代表一个死循环
                while (this.array[++i] < pivot) { }
                while (this.array[--j] > pivot) { }
                if (i < j) {
                    this.swap(i, j)
                } else {
                    break //不满足if条件，此时中断死循环
                }
            }

            // 3.将枢纽放在正确的位置,因为前面已经排好,所以有限制条件，不然会造成重复排序
           if(i<right-1){
            this.swap(i, right - 1)}

            // 4.递归调用左边部分
            
            this.quickSort(left, i - 1)

            // 4.递归调用右边部分
            this.quickSort(i + 1, right)              
        }
    }

    // 初始化数据项
    var list = new Arr()
    list.insert(7)
    list.insert(11)
    list.insert(70)
    list.insert(10)
    list.insert(6)
    list.insert(5)
    list.insert(101)
    list.insert(99)
    list.insert(50)
    list.insert(100)
    alert(list) // 7,11,70,10,6,5,101,99,50,100

    
    list.quick()// 测试快速排序
    alert(list)//5,6,7,10,11,50,70,99,100,101
</script>

多画画图比较容易理清

关键词:分而治之，递归，中位数，冒泡排序升级版

注意:快速排序不是一种稳定的算法，何为稳定，简单来说就是两个大小一样的数，多次用同一排序算法，两个数字出现的位置是否一样
快速排序有多种写法，但是核心思想都是分而治之