Javascript实现几种排序算法

1. 大O表示法：在算法描述中，用来粗略的度量算法的效率

2. 常见的大O表示形式

3. 排序算法

   • 封装列表 方便测试

   • 冒泡排序：

     • 效率较低，但思路简单
     • 效率：比较次数O(N²)，交换次数O(N²)

   • 选择排序：

     • 改进了冒泡排序
     • 选定第一个索引位置和后面的元素依次比较，找到除第一个元素意外以外的剩下元素最小的那个与第一个交换，然后用同样的方法逐个比较剩下的元素（每次选择最小或最大的元素）
     • 效率：比较次数O(N²)，交换次数O(N)

   • 插入排序：

     • 插入排序是高级排序（希尔排序/快速排序）的基础
     • 局部有序
       • 在队列中选择被标记的元素，这个元素的左边所有元素都是排好顺序的
     • 效率：是简单排序里效率最高的

   • 希尔排序：

     • 是插入排序的一种高效的改进版

     • 通过某种方式将小数据项靠左，大的数据项靠右移动
       

     • 需要选择合适的增量

   • 快速排序

     • 目前最快的一种排序算法，快速排序是比较好的选择
     • 可以看作冒泡排序的升级版，快速排序在一次循环中可以找出某个元素的正确位置，并且该元素之后不需要任何的移动
     • 分而治之：
     • 快速排序的枢纽（pivot也有人称为主元）
       • 取头、中、尾的中位数
       • 效率：O(N*logN)

   //创建列表类
   function ArrayList(){
     //属性
     this.array = [];
     
     //方法
     //将数据插入到数组中的方法
     ArrayList.prototype.insert = function(item){
       this.array.push(item);
     }
     //toString
     ArrayList.prototype.toString = function(){
       return this.array.join('-');
     }
     
     //实现排序算法
     //冒泡排序
     ArrayList.prototype.bubbleSort = function(){
       for(var i = 0 ; i<this.array.length ;i++){
         for(var j = 0 ;j<this.array.length-i;j++){
         	if(this.array[j]>this.array[j+1]){
           	var e = this.array[j+1];
             this.array[j+1] =this.array[j];
             this.array[j] = e;
           }
         }
       }
     }
     //选择排序
     ArrayList.prototype.selectSort = function(){
     	var length = this.array.length；
       
       var min = 0;
       for(var j =0;j<length;j++){
         var min = j;
         for(var i = min+1;i<length;i++){
           if(this.array[min]>this.array[i]){
             min = i;
           }
           //交换
           var e = this.array[j]
           this.array[j] =this.array[min];
           this.array[min] = e;
         }  
       }
     }
     //插入排序
     ArrayList.prototype.insertSort = function(){
     	var length = this.array.length;
       for(var i=1; i<length; 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--;
         }
         this.array[j] = temp;
       }
     }
     //希尔排序
     ArrayList.prototype.shellSort = function(){
     	var length =this.array.length;
       var gap =Math.floor(length/2);
       
       while(gap>=1){
         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;
           }
           this.array[j] = temp;
         }
         gap = Math.floor(gap/2);
       }
     }
     //快速排序
     ArrayList.prototype.quickSort = function(){
     	this.quick(0,this.array.length - 1);	  
     }
     ArrayList.prototype.quick = function(){
     	var pivot = this.median(left,right);
       var i = left;
       var j = right - 1;
       while(true){
         while(this.array[++i]<pivot){}
         while(this.array[--j]>pivot){}
         if(i<j){
           this.swap(i,j);
         }else{
           break;
         }
       }
       this.swap(i,right-1);
       this.quick(left,i-1);
       this.quick(i+1,right);
     }
     //选择枢纽
     ArrayList.prototype.median = function(left,right){
       var center = Math.floor((left + right)/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);
       }
       this.swap(center,right -1);
       return this.array(right -1);
     }
     
   }