js 排序算法实现

function ArrayList(){
        //属性
       this.array=[]
        //方法
        //将数据可以插入到数组中的方法
        ArrayList.prototype.insert=function(item){
           this.array.push(item)
        }

        //toString
        ArrayList.prototype.toString=function(){
            return this.array.join('-')
        }
       
       //交换两个位置的数据
       ArrayList.prototype.swap=function(m,n){
          var temp=this.array[m]
          this.array[m]=this.array[n]
          this.array[n]=temp
       }

        //实现排序算法
        //冒泡排序
        ArrayList.prototype.bubbleSort=function(){
            //1.获取数组的长度
            var length=this.array.length
            //第一次比较，i=0 比较0 和 1位置的两个数据，如果0位置大于 1位置的数据
            //最后一次进来 i=length-2，比较 length-2 和 length-1 的两个数据
            for(var j=length-1;j>=0;j--){
                for(var i=0;i<j;i++){
                    if(this.array[i]>this.array[i+1]){
                        //交换两个数据
                        this.swap(i,i+1)
                    }
               }
            }
           
        }

        //选择排序
         ArrayList.prototype.selectionSort=function(){
            //1.获取数组的长度
            var length=this.array.length

            //2.外层循环：从 0 位置开始取数据
            var min=0
            for(var j=0;j<length-1;j++){
                //内存循环：从 i+1位置开始，和后面的数据进行比较
                var min=j
                for(var i=min+1;i<length;i++){
                    if(this.array[min]>this.array[i]){
                        min=i
                    }
                }
                this.swap(min,j)
            }
         }

         //插入排序
         ArrayList.prototype.insertionSort=function(){
             //1.获取数组的长度
             var length=this.array.length
             //2.外层循环：从第1个位置开始获取数据，向前面局部有序进行插入
             for(var i=1;i<length;i++){
                 //3.内层循环：获取 i位置的元素，和前面的数据依次进行比较
                 var temp=this.array[i]
                 var j=i
                 while(this.array[j-1]>temp&&j>0){
                     this.array[j]=this.array[j-1]
                     j--
                 }
                 //4.将 j位置的数据，放置 temp就可以啦 
                 this.array[j]=temp
             }  
         }
        
        //希尔排序
        ArrayList.prototype.shellSort=function(){
            //1.获取数组的长度
            var length=this.array.length

            //2.初始化的增量
            var gap=Math.floor(length /2)

            //3.while 循环（gap不断的较小）
            while(gap>=1){
                //4.以 gap 作为间隔，进行分组，对分组进行插入排序
                for(var i=gap;i<length;i++){
                    var temp=this.array[i]
                    var j=i
                    while(this.array[j-gap]>temp&&j>gap-1){
                        this.array[j]=this.array[j-gap]
                        j-=gap
                    }

                    //5.将 j 位置的元素赋值 temp
                    this.array[j]=temp
                }
                //6.增量变化 /2
                gap=Math.floor(gap/2) 
            }
        }

        //快速排序
        //1.选择枢纽
        ArrayList.prototype.medium = function (left,right) {
            // 1. 取出中间的位置
            var center = Math.floor((left + right)/2);

            // 2. 判断大小，并且进行交换
            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);
            };

            // 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. 获取枢纽
            var pivot = this.medium(left , right);

            // 3. 定义变量，用于当前找到的位置
            var i = left;
            var j = right - 1;

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

            }
            // 5. 将枢纽放置在正确的位置，i的位置
            this.swap(i ,right-1);

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

    //测试类
    var list=new ArrayList()

    list.insert(66)
    list.insert(88)
    list.insert(12)
    list.insert(87)
    list.insert(100)
    list.insert(5)
    list.insert(566)
    list.insert(23)

    alert(list)
    //验证冒泡排序
    list.bubbleSort()
    alert(list)

   //2.验证选择排序
   list.selectionSort()
   alert(list)

   list.insertionSort()
   alert(list)

   //验证希尔排序
   list.shellSort()
   alert(list)

   //验证快速排序
   list.quickSort()
   alert(list)