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)