基于JavaScript的前端常用排序算法实现（1）

1.冒泡排序

简介：

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

算法原理：（从后往前）

1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

3.针对所有的元素重复以上的步骤，除了最后一个。

4.持续每次对越来越少的元素重复上面的步骤，知道没有任何一对数字需要比较。

JavaScript代码实现：

function bubbleSort(arr){    var i=0,j=0,temp=0;    for(i=1;i<arr.length;i++){        for(j=0;j<arr.length-i;j++){            //>从小打大            //<从大到小    if(arr[j]>arr[j+1]){    temp=arr[j];    arr[j]=arr[j+1];    arr[j+1]=temp;    }    }    }    return arr;}alert(bubbleSort([1,3,5,7,2,0,4]));//[0,1,2,3,4,5,7]

2.快速排序

简介：

快速排序是对冒泡排序的一种改进，也是使用最广泛、速度最快的排序方法。

原理：

1.在数据集里面选择一个元素作为‘基准’（pivot）。
2.所有小于‘基准’的元素，都移到‘基准’的左边；所有大于‘基准’的元素，都移到‘基准’的右边。
3.对‘基准’左边和右边的两个子集，不断重复第一步和第二步，直到所有子集只剩下一个元素为止。

JavaScript实现：

var quickSort = function(arr){    if(arr.length<=1){return arr;    }    var pivotIndex=Math.floor(arr.length/2);     //基准索引值    var pivotValue=arr.splice(pivotIndex,1)[0];//获取基准的数值    var leftValue=[];       //小于基准值的左边数据集    var rightValue=[];//大于等于基准值的右边数据集    for(var i=0;i<arr.length;i++){if(arr[i]<pivotValue){leftValue.push(arr[i]);    }else{rightValue.push(arr[i]);    }    }    return quickSort(leftValue).concat([pivotValue],quickSort(rightValue));    //迭代}alert(quickSort([85,24,63,45,17,31,96,50]));

3.二路并归排序算法

简介:

将两个按值有序序列合并成一个按值有序序列，则称之为二路并归排序，其可以分为自底向上和自顶向下的两种排序算法。

（1）自顶向下的并归排序，采用递归的方式，方法比较简单(但递归深度太深，一般不适用)

function mergeSort(arr){if(arr.length<=1){return arr;}var privotIndex=Math.floor(arr.length/2);var leftValue=arr.slice(0,privotIndex);var rightValue=arr.slice(privotIndex);if(leftValue=='undefined'&&rightValue=='undefined'){return false;}return merge(mergeSort(leftValue),mergeSort(rightValue));}function merge(leftValue,rightValue){var result=[];while(leftValue.length&&rightValue.length){if(leftValue[0]<=rightValue[0]){result.push(leftValue.shift());}else{result.push(rightValue.shift());}}while (leftValue.length){    result.push(leftValue.shift());  }   while (rightValue.length){    result.push(rightValue.shift());  }  return result;}var nums=[6,10,1,9,4,8,2,7,3,5];console.log(mergeSort(nums));

(2)上述通过迭代不是最好的实现方式，但下例函数功能与上述的函数相同但是没有使用递归。尽管迭代版本的合并排序算法比递归实现要慢一些，但它并不会像递归版本那样受调用栈限制的影响，把递归算法改用迭代实现是实现栈溢出错误的方法之一。

function merge(left, right) {  var result = [];  while (left.length && right.length) {    if (left[0] < right[0])      result.push(left.shift());    else      result.push(right.shift());  }  return result.concat(left, right);}function mergeSort(a) {  if (a.length === 1)    return a;  var work = [];  for (var i = 0, len = a.length; i < len; i++)    work.push([a[i]]);  work.push([]); // 如果数组长度为奇数  for (var lim = len; lim > 1; lim = ~~((lim + 1) / 2)) {    for (var j = 0, k = 0; k < lim; j++, k += 2)       work[j] = merge(work[k], work[k + 1]);    work[j] = []; // 如果数组长度为奇数  }  return work[0];}console.log(mergeSort([1, 3, 4, 2, 5, 0, 8, 10, 4]));