JavaScript数据结构与算法（6）排序算法

时间复杂度表示方式 大O表示法

冒泡排序

选择排序

插入排序

希尔排序

快速排序

代码实现

function ArrayList(){
    //属性
    this.array = []

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

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

    //交换两个位置数据
    ArrayList.prototype.swap = function(m,n){
        let temp = this.array[m]
        this.array[m] = this.array[n]
        this.array[n] = temp
    }

    //冒泡排序
    ArrayList.prototype.bubbleSort = function(){
        let length = this.array.length

        for(let j = length -1; j>=0;j--){
            for(let i=0;i<j;i++){
                if(this.array[i] > this.array[i+1]){
                    this.swap(i,i+1)
                }
            }
        }
    }

    //选择排序
    ArrayList.prototype.selectSort = function(){
        let length = this.array.length

        for(let j = length -1; j>=0;j--){
            let min = j
            for(let i=min+1;i<length -1;i++){
                if(this.array[min] > this.array[i]){
                    min = i
                }
            }
            this.swap(min,j)
        }
    }

    //插入排序
    ArrayList.prototype.insertSort = function(){
        let length = this.array.length

        for(let i=0;i<length -1;i++){
            let temp = this.array[i]
            let j = i
            while(this.array[j-1] > temp && j>0){
                this.array[j] = this.array[j-1]
                j--
            }
            this.array[j] = temp
        }
    }

    //希尔排序
    ArrayList.prototype.shellSort = function(){
        let length = this.array.length

        //初始化的增量(gap -> 间隔/间隙)
        let gap = Math.floor(length/2)

        //white循环（gap不断减小）
        while(gap >= 1){
            //以gap为间隔进行插入排序
            for(let i=gap;i<length;i++){
                let temp = this.array[i]
                let j = i
                while(this.array[j - gap] > temp && j > gap -1){
                    this.array[j] = this.array[j - gap]
                    j -= gap
                }
                
                // 将j位置的元素复制temp
                this.array[j] = temp
               
            }
            //增量变化
            gap = Math.floor(gap/2)
        }
    }

    //快速排序
    //1、选择枢纽
    ArrayList.prototype.median = function(left,right){
        //1、取出中间位置
        let 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[right]){
            this.swap(left,right)
        }

        //3、将center换到right-1的位置
        this.swap(center,right-1)

        return this.array[right - 1]
    }

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

    ArrayList.prototype.quick = function(left,right){
        // 1、结束条件
        if(left >= right){
            return
        }

        // 2、获取枢纽
        let pivot = this.median(left,right)

        // 3、定义变量，用于记录当前找到的位置
        let i = left
        let j = right - 1

        // 4、开始进行交换
        while(true){
            while(this.array[i] < pivot){
                i++
            }
            while(this.array[j] > pivot){
                j--
            }
            if(i<j){
                this.swap(i,j)
            }else{
                break
            }
        }

        //6、将枢纽防止在正确的位置，i耳闻之
        this.swap(i,right -1)

        // 7、分而治之
        this.quick(left,i-1)
        this.quick(i+1,right-1)
    }
}