JS实现冒泡，选择，插入，希尔，快速排序

 

 

 

 

 

function ArrayList() {
    this.array = [];

    ArrayList.prototype.insert = function (data) {
        this.array.push(data)
    }

    ArrayList.prototype.toString = function () {
        return this.array.join("-");
    }

    ArrayList.prototype.swap = function (i1, i2) {
        var temp = this.array[i1];
        this.array[i1] = this.array[i2];
        this.array[i2] = temp;
    }

    //冒泡排序 交换 O(n^2) 比较 O(n^2)
    ArrayList.prototype.bubbleSort = function () {
        // 1.两层循环
        // 1.1第一层循环，计算出要进行交换的排序
        for (let i = 0; i < this.array.length; i++) {
            // 1.2第二层循环将每个元素与后面的元素比较，交换。 
            for (let j = 1; j < this.array.length - i; j++) {
                let a = this.array[j - 1];
                let b = this.array[j];
                if (a > b) {
                    this.swap(j - 1, j);
                }
            }
        }
    }

    //选择排序  交换 O(n) 比较 O(n^2)
    ArrayList.prototype.chooseSort = function () {
        //1.计算需要交换的排数
        for (let i = 0; i < this.array.length; i++) {
            //2.每一排查找最小值的下标
            let max = i;
            for (let j = i + 1; j < this.array.length; j++) {
                if (this.array[max] > this.array[j]) {
                    max = j;
                }
            }
            //3.交换
            this.swap(max, i);
        }
    }

    //插入排序  交换 O(n^2) 比较 O(n^2)
    ArrayList.prototype.insertSort = function () {

        //1.计算要赋值的排数，因为第一个数字已经排序好，所以从i=1开始  //2.保留要进行比较的temp值以及插入位置J,为了后面的比较跟赋值//3.寻找插入j的位置以及后移有序数组的元素
        for (let i = 1; i < this.array.length; i++) {

            //2.保留要进行比较的temp值以及插入位置J,为了后面的比较跟赋值
            let temp = this.array[i];
            let j = i;

            //3.寻找插入j的位置以及后移有序数组的元素
            while (temp < this.array[j - 1] && j > 0) {
                this.array[j] = this.array[j - 1];
                j--;
            }

            //4.赋值
            this.array[j] = temp;
        }
    }

    // 希尔排序 O(n^2)
    ArrayList.prototype.shellSort = function () {

        //1.初始化间隔grap
        var grap = Math.floor(this.array.length / 2);

        //2.循环间隔grap>=1
        while (grap >= 1) {

            //3.根据grap的分组进行插入排序
            //3.1插入的排数起始为grap
            for (let i = grap; i < this.array.length; i += grap) {
                //3.2保留temp和j，方便后面进行比较跟赋值
                let temp = this.array[i];
                let j = i;
                //3.3while循环比较temp和array[j],后移数组元素
                while (temp < this.array[j - grap] && j > 0) {
                    this.array[j] = this.array[j - grap];
                    j -= grap;
                }
                //3.4赋值
                this.array[j] = temp;
            }
            //4.Math.floor,grap/2
            grap = Math.floor(grap / 2);
        }
    }

    //快速排序之选择枢纽
    ArrayList.prototype.quicklySortAboutChooseMiddle = function (left, right) {
        // 1.根据left和right求出center指针
        var center = Math.floor((left+right)/2);
        // 2.连续3个if将他们按从小到大排序
        if(this.array[left] > this.array[center]) {
            this.swap(left,center);
        }
        if(this.array[left] > this.array[right]) {
            this.swap(left,right);
        }
        if(this.array[center] > this.array[right]) {
            this.swap(center,right);
        }
        if(this.array[center] < this.array[left]) {
            this.swap(center,left);
        }
        // 3.将center与right-1交换
        this.swap(center,right-1);
        // 4.返回中位数的索引值
        return this.array[right-1];
    }



    //快速排序
    ArrayList.prototype.quicklySort =function() {
        this.quicklySortAboutDigui(0,this.array.length-1);
    }
    //快速排序之递归
    ArrayList.prototype.quicklySortAboutDigui = function(left,right){
        //1.递归结束条件
        if(left >= right ) return;

        //2.获取中位数的值
        var provt = this.quicklySortAboutChooseMiddle(left,right);

        //3.while(true)循环将小于最右边的值，大于最右边的值分区摆好
        let l = left;
        let r = right-1;

        while(1) {
            //3.1通过while(this.array[++l] > 最右边的值)查找到要替换的下标
            while(this.array[++l] < provt  && l < r) {};
            //3.2通过while(this.array[--r] < 最右边的值)查找到要替换的下标
            while(this.array[--r] > provt  && l < r) {};
            //3.3大数跟小数交换位置
            if(l < r) {
                this.swap(l,r);
            }else {
                break;
            }
        }
        //4.确定中位数的位置
        this.swap(l,right-1);
        //5.递归左边
        this.quicklySortAboutDigui(left,l-1);
        //6.递归右边
        this.quicklySortAboutDigui(l+1,right);
    }
}
var array = new ArrayList();

array.insert(6)
array.insert(63)
array.insert(16)
array.insert(8566)
array.insert(6111)
array.insert(6161)
array.insert(61521)
array.insert(6921)
console.log(array.toString());
array.quicklySort()
console.log(array.toString());