冒泡排序、插入排序、选择排序、快速排序、归并排序、希尔排序

最新推荐文章于 2021-12-15 14:10:29 发布

原创最新推荐文章于 2021-12-15 14:10:29 发布 · 240 阅读

0 ·

CC 4.0 BY-SA版权

前端知识专栏收录该内容

19 篇文章

订阅专栏

本文深入讲解了六种经典的排序算法，包括冒泡排序、插入排序、选择排序、快速排序、归并排序和希尔排序。每种算法都附有详细的代码实现，帮助读者理解其工作原理及优劣。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、冒泡排序：两两比较，逆序则交换，和吐泡泡一样，咕噜咕噜～，每次把最小/大的数据放在前面

        var arr = [7,5,61,2,3,14];

        for (let i = 0; i < arr.length-1; i++) {
            for (let j = i+1; j < arr.length; j++) {
                if(arr[i]>arr[j]) {
                    const temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                }
            }
        }

        console.log(arr);

二、插入排序：将未排序的数据插入已经排好序的部分中

        var arr = [7,5,61,2,3,14];

        for (let i = 1; i < arr.length; i++) {
            let temp = arr[i];
            let j = i-1;
            for (j = i-1; j > -1; j--) {
                console.log("i is ="+i+"j is ="+j);
                if(temp < arr[j]) {
                    arr[j+1] = arr[j];
                }else {
                    break;
                }
            }
            arr[j+1] = temp;
        }

        console.log(arr);

三、选择排序：每一次找一个最小值，第i次找到的最小值与arr[i]交换数值

        var arr = [7,5,61,2,3,14];

        for (let i = 0; i < arr.length-1; i++) {
            let temp = i;
            for (let j = i+1; j < arr.length; j++) {
                if(arr[j]<arr[temp]) {
                    temp = j;
                }
            }
            let zan = arr[i];
            arr[i] = arr[temp];
            arr[temp] = zan;
        }

        console.log(arr);

四、快速排序：每次找一个元素做一个基准，小于基准的放left[]，大于基准的放right[]，基准值中立，递归拆分排序，当数组里只剩一个数据时，返回数组，向上归并。

        var arr = [7,5,61,12,6,7];
        console.log(arr);

        function sst(res) {
            let len = res.length;
            if(len<=1) return res;
            let middle = Math.floor(len/2);
            let left = [],right = [];
            for (let i = 0; i < len; i++) {
                if(i==middle) continue;
                if(res[middle]>=res[i]) left.push(res[i]);
                else right.push(res[i]);
            }

            return sst(left).concat([res[middle]]).concat(sst(right));
        }

        console.log(sst(arr));

五、归并排序：和快速排序差不多，都是分而治之，区别在于归并排序的left[]和right[]长度各为一半一半，是按个数拆分的，而快速排序的left[]和right[]长度，是跟据选择的基准的大小拆分的。

        var arr = [7,5,61,12,6,7];

        function sst(res) {
            let len = res.length;
            if(len<=1) return res;
            let middle = Math.floor(len/2);
            let left = sst(res.splice(0,middle));
            let ress = sst(res);
            let newres = [];
            let ll = 0,rr = 0,llen = left.length,rlen = ress.length;
            for (let i = 0; i < llen+rlen; i++) {
                if(ll==llen) {
                    newres = newres.concat(ress.splice(rr,rlen));
                    break;
                }else if(rr==rlen) {
                    newres = newres.concat(left.splice(ll,llen));
                    break;
                }else {
                    if(left[ll]<ress[rr]) {
                        newres.push(left[ll]);
                        ll++;
                    }else {
                        newres.push(ress[rr]);
                        rr++;
                    }
                }
            }
            return newres;
        }

        console.log(sst(arr));

六、希尔排序：有增量的插入排序，每趟按增量distance分组，并将每组分组进行插入排序，但是这里的增量的变换方式不同，将影响整个算法的优劣，之前在《数据结构》书中看到上面说经过大量研究，当增量序列为dlta[k] = 2^(t-k+1)时，希尔排序的时间复杂度为O（n^1.5）

        var arr = [7,5,61,12,6,7,1];

        function sst(res) {
            let len = res.length;
            let distence = Math.floor(len/2);

            while(distence>=1) {
                for (let j = 0; j < distence; j++) {
                    for (let i = distence+j; i < len; i = i+distence) {
                        let temp = res[i];
                        let k = i-distence;
                        for (k = i-distence; k >=0; k = k-distence) {
                            if(temp<res[k]) {
                                res[k+distence] = res[k];
                            }else {
                                res[k+distence] = temp;
                                break;
                            }
                        }
                        if(k<0) {
                            res[k+distence] = temp;
                        }
                    }
                }
                distence = Math.floor(distence/2);
            }
            return res;
        }

        console.log(sst(arr));