javaScript实现排序

稳定排序和不稳定排序 （7大排序的稳定性分析）
稳定排序有：插入排序、冒泡排序、归并排序 、基数排序（插冒归并基）
不稳定排序：希尔排序、快速排序、选择排序、堆排序（希尔快选堆）
各种排序算法稳定性分析
现在分析一下常见的排序算法的稳定性，每个都给出简单的理由。 
（1）冒泡排序 
冒泡排序就是把小的元素往前调（或者把大的元素往后调）。注意是相邻的两个元素进行比较，而且是否需要交换也发生在这两个元素之间。
所以，如果两个元素相等，我想你是不会再无聊地把它们俩再交换一下。
如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个元素相邻起来，最终也不会交换它俩的位置，所以相同元素经过排序后顺序并没有改变。
所以冒泡排序是一种稳定排序算法。 
冒泡排序-排序思想:
1.比较相邻的两个元素，如果前一个比后一个大，则交换位置。2.第一轮的时候最后一个元素应该是最大的一个。3.按照步骤一的方法进行相邻两个元素的比较，这个时候由于最后一个元素已经是最大的了，所以最后一个元素不用比较。
function bubbleSort(arr){
        for(var i=0;i<arr.length-1;i++){
            for(var j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                     var temp=arr[j];
                     arr[j]=arr[j+1];
                     arr[j+1]=temp;
                }
            }
        }
        return arr;
}
var arr=[3,45,2,5,33,46,55,4,30];
console.log(bubbleSort(arr));//2,3,4,5,30,33,45,46,55
（2）选择排序
选择排序即是给每个位置选择待排序元素中当前最小的元素。比如给第一个位置选择最小的，在剩余元素里面给第二个位置选择次小的，依次类推，直到第n-1个元素，第n个元素不用选择了，因为只剩下它一个最大的元素了。那么，在一趟选择时，如果当前锁定元素比后面一个元素大，而后面较小的那个元素又出现在一个与当前锁定元素相等的元素后面，那么交换后位置顺序显然改变了。举个例子：序列5 8 5 2 9， 我们知道第一趟选择第1个元素5会与2进行交换，那么原序列中两个5的相对先后顺序也就被破坏了。所以选择排序不是一个稳定的排序算法。
 
选择排序-排序思想：
1.首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置；
2.再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾；
3.以此类推，直到所有元素均排序完毕。
function selectSort(arr){var len=arr.length;var minIndex,temp;for(var i=0;i<len-1;i++){minIndex=i;  for(var j=i+1;j<len;j++){       if(arr[j]<arr[minIndex]){//寻找最小数       minIndex=j;//保存最小数的索引       }  }  temp=arr[i];  arr[i]=arr[minIndex];  arr[minIndex]=temp;}return arr; }var arr=[3,45,2,5,33,46,55,4,30];document.write(selectSort(arr));//2,3,4,5,30,33,45,46,55

（3）插入排序
插入排序是在一个已经有序的小序列的基础上，一次插入一个元素。当然，刚开始这个有序的小序列只有1个元素，也就是第一个元素（默认它有序）。比较是从有序序列的末尾开始，也就是把待插入的元素和已经有序的最大者开始比起，如果比它大则直接插入在其后面。否则一直往前找直到找到它该插入的位置。如果遇见一个与插入元素相等的，那么把待插入的元素放在相等元素的后面。所以，相等元素的前后顺序没有改变，从原无序序列出去的顺序仍是排好序后的顺序，所以插入排序是稳定的。
 
插入排序-排序思想：
    每次将一个待排序的数据元素，插入到前面已经排好序的数列中的适当位置，使数列依然有序；直到待排序数据元素全部插入完。
function insertionSort(arr){  var temp,j;  for(var i=1;i<arr.length;i++){            temp=arr[i];            j=i;            while(j>=0&&temp<arr[j-1]){//在剩余的序列中找到最小的元素              arr[j]=arr[j-1];              --j;            }            arr[j]=temp;  }}var elements = [10, 9, 8, 7, 6, 5];console.log('before: ' + elements);insertionSort(elements);console.log(' after: ' + elements);//[5,6,7,8,9,10]
（4）快速排序
快速排序有两个方向，左边的i下标一直往右走（当条件a[i] <= a[center_index]时），其中center_index是中枢元素的数组下标，一般取为数组第0个元素。
而右边的j下标一直往左走（当a[j] > a[center_index]时）。如果i和j都走不动了，i <= j, 交换a[i]和a[j],重复上面的过程，直到i>j。交换a[j]和a[center_index]，完成一趟快速排序。在中枢元素和a[j]交换的时候，很有可能把前面的元素的稳定性打乱，比如序列为 5 3 3 4 3 8 9 10 11 现在中枢元素5和3(第5个元素，下标从1开始计)交换就会把元素3的稳定性打乱。所以快速排序是一个不稳定的排序算法，不稳定发生在中枢元素和a[j]交换的时刻。 
快速排序算法
 快速排序是对冒泡排序的一种改进，第一趟排序时将数据分成两部分，一部分比另一部分的所有数据都要小。然后递归调用，在两边都实行快速排序。排序思想:
1、在数据集中选取一个元素作为基准；2、所有小于基准的元素都移到基准的左边，所有大于基准的元素都移到基准的右边；3、对基准的左边和右边分别重复第1、2步，直到所有子集只剩下一个元素为止。
function quickSort(arr){if(arr.length<=1){return arr;}var pivotIndex=Math.floor(arr.length/2);//取数组中间的元素作为基准var pivot=arr.splice(pivotIndex,1)[0];//splice从数组中删除中间一项。并返回被删除的元素，作为基准var left=[];var right=[];for(var i=0;i<arr.length;i++){if(arr[i]<pivot){left.push(arr[i]);}else{right.push(arr[i]);}}return quickSort(left).concat([pivot],quickSort(right));};var arr=[3,45,2,5,33,46,55,4,30];document.write(quickSort(arr));//2,3,4,5,30,33,45,46,55

（5）归并排序
归并排序是把序列递归地分成短序列，递归出口是短序列只有1个元素(认为直接有序)或者2个序列(1次比较和交换)，然后把各个有序的段序列合并成一个有序的长序列，不断合并直到原序列全部排好序。可以发现，在1个或2个元素时，1个元素不会交换，2个元素如果大小相等也没有人故意交换，这不会破坏稳定性。那么，在短的有序序列合并的过程中，稳定是是否受到破坏？没有，合并过程中我们可以保证如果两个当前元素相等时，我们把处在前面的序列的元素保存在结果序列的前面，这样就保证了稳定性。所以，归并排序也是稳定的排序算法。
 
（6）基数排序
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。
有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序，最后的次序结果就是高优先级高的在前，高优先级相同的情况下低优先级高的在前。
基数排序基于分别排序，分别收集，所以其是稳定的排序算法。
（7）希尔排序
希尔排序是按照不同步长对元素进行插入排序，当刚开始元素很无序的时候，步长最大，所以插入排序的元素个数很少，速度很快；当元素基本有序时，步长很小，插入排序对于有序的序列效率很高。所以，希尔排序的时间复杂度会比O(N^2)好一些。由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱。所以shell排序是不稳定的排序算法。 
（8）堆排序(不稳定)
我们知道堆的结构是节点i的孩子为2*i和2*i+1节点，大顶堆要求父节点大于等于其2个子节点，小顶堆要求父节点小于等于其2个子节点。
在一个长为n的序列，堆排序的过程是从第n/2开始和其子节点共3个值选择最大（大顶堆）或者最小（小顶堆），这3个元素之间的选择当然不会破坏稳定性。
但当为n/2-1, n/2-2, ...1这些个父节点选择元素时，就会破坏稳定性。
有可能第n/2个父节点交换把后面一个元素交换过去了，而第n/2-1个父节点把后面一个相同的元素没有交换，那么这2个相同的元素之间的稳定性就被破坏了。
所以，堆排序不是稳定的排序算法。
 操作过程如下：
     1)初始化堆：将R[1..n]构造为堆；
     2)将当前无序区的堆顶元素R[1]同该区间的最后一个记录交换，然后将新的无序区调整为新的堆。
    因此对于堆排序，最重要的两个操作就是构造初始堆和调整堆，其实构造初始堆事实上也是调整堆的过程，只不过构造初始堆是对所有的非叶节点都进行调整。

二分法查找
思想：
1)、首先对所要查找的数据集进行排序，然后将目标元素与数据集中间位置的元素进行比较；
2)、若目标元素正好等于中间位置的元素，则结束查找，否则进行下一步；
3)、若目标元素大于或小于中间位置的元素，则在大于或小于中间位置元素的那一半进行查找，然后重复第一步；
4)、如果某一步的数组为空了，则表示找不到该元素；
非递归算法：
function binarySearch(arr,key){
var low=0;
var high=arr.length-1;
while(low<=high){
var mid=parseInt((high+low)/2);
if(arr[mid]==key){
return mid;
}else if(key>arr[mid]){
low=mid+1;
}else if(key<arr[mid]){
high=mid-1;
}else{
return -1;
}
}
};
var arr=[1,2,3,4,5,6,7,8,9,20];
var result=binarySearch(arr,8);
alert(result);
递归算法：
function binarySearch(arr,low,high,key){
if(low>high){
return -1;
}
var mid=parseInt((low+high)/2);
if(arr[mid]==key){
return mid;
}else if(arr[mid]>key){
high=mid-1;
return binarySearch(arr,low,high,key);
}else(arr[mid]<key){
low=mid+1;
return binarySearch(arr,low,high,key);
}
}
var arr=[1,2,3,4,5,6,7,8,9,20];
var result=binarySearch(arr,0,9,8);
return result;