JavaScript实现几种常见的排序排序算法

1.Array类的封装

class Array {
    constructor() {
        this.array = [];

        Array.prototype.insert = function (arr) {
            this.array.push(arr)
        }

        Array.prototype.toString = function () {
            return this.array.join(" ")
        }

2.冒泡排序

 // 冒泡排序:两两进行比较,数字大的排到小的数字的后面,比较次数为等差数列n*(n-1)/2,时间复杂度为O(n*n)
        Array.prototype.bubbleSort = function () {
            var arr = this.array;
            for (var i = 0; i < arr.length; i++) {
                for (var j = 0; j < arr.length - i; j++) {
                    if (arr[j] > arr[j + 1]) {
                        [arr[j + 1], arr[j]] = [arr[j], arr[j + 1]]
                        // 或者var t=arr[j+1];
                        // arr[j+1]=arr[j];
                        // arr[j]=t
                    }
                }
            }
            return arr
        }

3.选择排序

// 选择排序:用下标值为0,1,...,n-1的数与后面的数依次进行比较,每次都选择出一个最小的数与其交换位置
        // 选择排序的比较次数的时间复杂度也为O(n*n),但是交换次数为n-1,表示为O(n),所以执行效率上还是高于冒泡排序的
        Array.prototype.selectionSort = function () {
            var arr = this.array;
            // 外层循环,用下标为0的数开始与其他数进行比较
            for(var j=0;j<arr.length-1;j++){
                var min=j;
                // 内层循环,从min+1的位置的数开始与min进行比较
             for(var i=min+1;i<arr.length;i++){
                 if(arr[min]>arr[i]){
                     min=i
                 }
             }
            [arr[j],arr[min]]=[arr[min],arr[j]]
            }
            return arr
        }

3.插入排序

// 插入排序:将每个数插入到前面的局部有序的数据中去,比较次数最多为1+2+...+n-1次,平均为最多的一半,即n*(n-1)/4
        Array.prototype.insertSort=function(){
            var arr=this.array;
            // 从下标为1的数开始遍历每个数
            for(var i=1;i<arr.length;i++){
                var j=i;
                var temp=arr[i];
                // 将这个数与前面的局部有序数字进行比较,并将比这个数大的数向后位移
                while(arr[j-1]>temp&&j>0){
                    arr[j]=arr[j-1];
                    j--;
                }
                // 将这个数放置到局部有序数组中选出的位置上去
                arr[j]=temp
            }
            return arr
        }

4.希尔排序

// 希尔排序:插入排序的改进版,将具有一定间隔的数分组,对分组进行插入排序,时间复杂度通常情况下优于o(n*n)
        Array.prototype.shellSort=function(){
            var arr=this.array;
            // 初始化间隔
            var gap=Math.floor(arr.length/2);
            // 间隔不断减小
            while(gap>=1){
                // 以gap作为间隔进行分组,对分组进行插入排序
                for(var i=gap;i<arr.length;i++){
                    var j=i;
                    while(arr[j-gap]>arr[i]&&j>gap-1){
                        arr[j]=arr[j-gap];
                        j-=gap;
                    }
                    arr[j]=arr[i]
                }
                gap=Math.floor(gap/2)
            }
            return arr
        }

5.快速排序

// 快速排序:时间复杂度平均为o(n*logn)

        //先将枢纽选择出来
        Array.prototype.median=function(left,right){
            var arr=this.array;
            // 取出中间的位置
            var center=Math.floor((left+right)/2);
            // 判断条件,并进行交换
            if(arr[left]>arr[center]){
                [arr[left],arr[center]]=[arr[center],arr[left]]
            }
            if(arr[left]>arr[right]){
                [arr[left],arr[right]]=[arr[right],arr[left]]
            }
            if(arr[center]>arr[right]){
                [arr[center],arr[right]]=[arr[right],arr[center]]
            }
            // 将最后在中间的数与倒数第二个数交换位置,并取出
            [arr[center],arr[right-1]]=[arr[right-1],arr[center]];

              return arr[right-1]

        }

        // 快速排序的实现
        Array.prototype.quickSort=function(){
            this.quick(0,this.array.length-1);
            return this.array
        }

        Array.prototype.quick=function(left,right){
        //结束条件
        if(left>=right)return;
        //获取枢纽
        var pivot=this.median(left,right);
        // 定义变量,用于记录当前找到的位置
        var i=left;
        var j=right-1;
        // 开始进行交换
        while(i<j){
            while(this.array[++i]<pivot){};
            while(this.array[--j]>pivot){};
            if(i<j){
                [this.array[i],this.array[j]]=[this.array[j],this.array[i]]
            }else{
                break
            }
        }
        // 将枢纽放在i的位置上
        
        [this.array[i],this.array[right-1]]=[this.array[right-1],this.array[i]]
    
        // 分别对i左右的数组进行递归
        this.quick(left,i-1);
        this.quick(i+1,right)
        }