快速排序算法的性能比较

Posted fhc1994

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了快速排序算法的性能比较相关的知识,希望对你有一定的参考价值。

一、前言

  最近又遇到快速排序算法了,才发现以前学的那种快速排序算法有问题,在此记录一下两种不同快速排序算法的性能比较

二、快速排序算法

2.1 方法一

思路:

  ①选择数组中间数作为基数,并从数组中取出此基数

  ②准备两个新数组容器,遍历数组,逐个与基数比对,较小的放左边容器,较大的放右边容器

  ③递归处理两个容器的元素,并将处理后的数据与基数按大小合并成一个数组,返回

实现:

// 方法一
function quick_1(ary) {
    //4.结束递归(当ARY中小于等于一项,则不用处理)
    if (ary.length <= 1) {
        return ary
    }
    // 1.找到数组的中间项,在原有的数组中把它移除
    let middleIndex = Math.floor(ary.length / 2)
    let middleValue = ary.splice(middleIndex, 1)[0]
    //2.准备左右两个数组,循环剩下数组中的每一项,比当前项小的放到左边数组中,反之放到右边数组当中
    let aryLeft = [],
        aryRight = []
    for (let i = 0; i < ary.length; i++) {
        ary[i] < middleValue ? aryLeft.push(ary[i]) : aryRight.push(ary[i])
    }
    //3.递归方式让左右两边的数组持续这样处理,一直到左右两边都排好序为止(最后让左边+中间+右边拼接成为最后的结果)
    return quick_1(aryLeft).concat(middleValue, quick_1(aryRight))
} 

缺点:

  ①调用函数删除基数会更耗时

  ②专门生成两个数组来存储,增加了空间复杂度

2.2 方法二

思路:

  ①选定pivot中心轴

  ②设定两个下标L和R,不断从右向左移动R下标,一旦发现比pivot小的数字,则把该数字放到L所指的位置;然后不断向右移动L下标,一旦发现比pivot大的数字,则把该数字放到R所指的位置;然后从右向左移动R下标,重复执行之前的步骤,直到L等于R,结束第一次排序

  ③分别对左右子序列重复前两步操作

实现:

// 方法二
function quick_2(arry) {
    return quick(arry, 0, arry.length - 1)
}

function quick(arry, L, R) {
    if (L >= R) return
    let left = L
    let right = R
    let pivot = arry[left]
    while (left < right) {
        while (left < right && arry[right] >= pivot) {
            right--
        }
        if (left < right) {
            arry[left] = arry[right]
        }
        while (left < right && arry[left] <= pivot) {
            left++
        }
        if (left < right) {
            arry[right] = arry[left]
        }
        if (left >= right) {
            arry[left] = pivot
        }
    }
    quick(arry, L, right - 1)
    quick(arry, right + 1, R)
}

优点:

  ①利用双指针移动下标取数,更快

  ②不需要创建新数组存储被划分的数据,降低了空间复杂度

三、性能比较

测试:

  选取100000个随机整数,利用两种不同思路的快速排序方法进行性能测试

// 方法一
function quick_1(ary) {
    //4.结束递归(当ARY中小于等于一项,则不用处理)
    if (ary.length <= 1) {
        return ary
    }
    // 1.找到数组的中间项,在原有的数组中把它移除
    let middleIndex = Math.floor(ary.length / 2)
    let middleValue = ary.splice(middleIndex, 1)[0]
    //2.准备左右两个数组,循环剩下数组中的每一项,比当前项小的放到左边数组中,反之放到右边数组当中
    let aryLeft = [],
        aryRight = []
    for (let i = 0; i < ary.length; i++) {
        ary[i] < middleValue ? aryLeft.push(ary[i]) : aryRight.push(ary[i])
    }
    //3.递归方式让左右两边的数组持续这样处理,一直到左右两边都排好序为止(最后让左边+中间+右边拼接成为最后的结果)
    return quick_1(aryLeft).concat(middleValue, quick_1(aryRight))
}


// 方法二
function quick_2(arry) {
    return quick(arry, 0, arry.length - 1)
}

function quick(arry, L, R) {
    if (L >= R) return
    let left = L
    let right = R
    let pivot = arry[left]
    while (left < right) {
        while (left < right && arry[right] >= pivot) {
            right--
        }
        if (left < right) {
            arry[left] = arry[right]
        }
        while (left < right && arry[left] <= pivot) {
            left++
        }
        if (left < right) {
            arry[right] = arry[left]
        }
        if (left >= right) {
            arry[left] = pivot
        }
    }
    quick(arry, L, right - 1)
    quick(arry, right + 1, R)
}

// 生成num个m到n范围内的随机整数
function getRandom(m, n, num) {
    let list = []
    for (let i = 0; i < num; i++) {
        let random = Math.floor(Math.random() * (n - m) + m)
        list.push(random)
    }
    return list
}

let ary = getRandom(1, 100000, 100000)
let ary1 = [...ary]
let ary2 = [...ary]

console.time(‘quick_1‘)
quick_1(ary1)
console.timeEnd(‘quick_1‘)

console.time(‘quick_2‘)
quick_2(ary2)
console.timeEnd(‘quick_2‘)

测试结果:(在谷歌浏览器上测试)

技术图片

 

结论:

方法二实现排序更快速更省空间

四、参考

https://www.cnblogs.com/hjx-blog/articles/9183453.html

https://www.bilibili.com/video/BV1at411T75o?from=search&seid=11059659226640382451

https://www.bilibili.com/video/BV1YE411a7zK

 

以上是关于快速排序算法的性能比较的主要内容,如果未能解决你的问题,请参考以下文章

交换排序(冒泡排序快速排序的算法思想及代码实现)

快速排序-递归实现

快速排序的性能和名字一样优秀

快速排序算法

排序算法——快速排序的图解代码实现以及时间复杂度分析

Unity中的快速排序算法&&二分查找