function bubbleSort(arr){
var len = arr.length;for(var i =0; i < len -1; i++){for(var j =0; j < len -1- i; j++){if(arr[j]> arr[j+1]){// 相邻元素两两对比
var temp = arr[j+1];// 元素交换
arr[j+1]= arr[j];
arr[j]= temp;}}}return arr;}
function selectionSort(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;}
插入排序(Insertion Sort)
算法描述
从第一个元素开始,该元素可以认为已经被排序;
取出下一个元素,在已经排序的元素序列中从后向前扫描;
如果该元素(已排序)大于新元素,将该元素移到下一位置;
重复步骤3,直到找到已排序的元素小于或者等于新元素的位置;
将新元素插入到该位置后;
重复步骤2~5。
示例代码
function insertionSort(arr){
var len = arr.length;
var preIndex, current;for(var i =1; i < len; i++){
preIndex = i -1;
current = arr[i];while(preIndex >=0&& arr[preIndex]> current){
arr[preIndex +1]= arr[preIndex];
preIndex--;}
arr[preIndex +1]= current;}return arr;}
function shellSort(arr){
var len = arr.length;for(var gap = Math.floor(len /2); gap >0; gap = Math.floor(gap /2)){// 注意:这里和动图演示的不一样,动图是分组执行,实际操作是多个分组交替执行for(var i = gap; i < len; i++){
var j = i;
var current = arr[i];while(j - gap >=0&& current < arr[j - gap]){
arr[j]= arr[j - gap];
j = j - gap;}
arr[j]= current;}}return arr;}
归并排序(Merge Sort)
算法描述
把长度为n的输入序列分成两个长度为n/2的子序列;
对这两个子序列分别采用归并排序;
将两个排序好的子序列合并成一个最终的排序序列。
示例代码
function mergeSort(arr){
var len = arr.length;if(len <2){return arr;}
var middle = Math.floor(len /2),
left = arr.slice(0, middle),
right = arr.slice(middle);returnmerge(mergeSort(left),mergeSort(right));}
function merge(left, right){
var result =[];while(left.length>0&& right.length>0){if(left[0]<= right[0]){
result.push(left.shift());}else{
result.push(right.shift());}}while(left.length)
result.push(left.shift());while(right.length)
result.push(right.shift());return result;}
function quickSort(arr, left, right){
var len = arr.length,
partitionIndex,
left = typeof left !='number'?0: left,
right = typeof right !='number'? len -1: right;if(left < right){
partitionIndex =partition(arr, left, right);quickSort(arr, left, partitionIndex-1);quickSort(arr, partitionIndex+1, right);}return arr;}
function partition(arr, left ,right){// 分区操作
var pivot = left,// 设定基准值(pivot)
index = pivot +1;for(var i = index; i <= right; i++){if(arr[i]< arr[pivot]){swap(arr, i, index);
index++;}}swap(arr, pivot, index -1);return index-1;}
function swap(arr, i, j){
var temp = arr[i];
arr[i]= arr[j];
arr[j]= temp;}
var len;// 因为声明的多个函数都需要数据长度,所以把len设置成为全局变量
function buildMaxHeap(arr){// 建立大顶堆
len = arr.length;for(var i = Math.floor(len/2); i >=0; i--){heapify(arr, i);}}
function heapify(arr, i){// 堆调整
var left =2* i +1,
right =2* i +2,
largest = i;if(left < len && arr[left]> arr[largest]){
largest = left;}if(right < len && arr[right]> arr[largest]){
largest = right;}if(largest != i){swap(arr, i, largest);heapify(arr, largest);}}
function swap(arr, i, j){
var temp = arr[i];
arr[i]= arr[j];
arr[j]= temp;}
function heapSort(arr){buildMaxHeap(arr);for(var i = arr.length -1; i >0; i--){swap(arr,0, i);
len--;heapify(arr,0);}return arr;}
计数排序(Counting Sort)
算法描述
找出待排序的数组中最大和最小的元素;
统计数组中每个值为i的元素出现的次数,存入数组C的第i项;
对所有的计数累加(从C中的第一个元素开始,每一项和前一项相加);
反向填充目标数组:将每个元素i放在新数组的第C(i)项,每放一个元素就将C(i)减去1。
示例代码
function countingSort(arr, maxValue){
var bucket =newArray(maxValue +1),
sortedIndex =0;
arrLen = arr.length,
bucketLen = maxValue +1;for(var i =0; i < arrLen; i++){if(!bucket[arr[i]]){
bucket[arr[i]]=0;}
bucket[arr[i]]++;}for(var j =0; j < bucketLen; j++){while(bucket[j]>0){
arr[sortedIndex++]= j;
bucket[j]--;}}return arr;}
桶排序(Bucket Sort)
算法描述
设置一个定量的数组当作空桶;
遍历输入数据,并且把数据一个一个放到对应的桶里去;
对每个不是空的桶进行排序;
从不是空的桶里把排好序的数据拼接起来。
示例代码
function bucketSort(arr, bucketSize){if(arr.length ===0){return arr;}
var i;
var minValue = arr[0];
var maxValue = arr[0];for(i =1; i < arr.length; i++){if(arr[i]< minValue){
minValue = arr[i];// 输入数据的最小值}elseif(arr[i]> maxValue){
maxValue = arr[i];// 输入数据的最大值}}// 桶的初始化
var DEFAULT_BUCKET_SIZE =5;// 设置桶的默认数量为5
bucketSize = bucketSize || DEFAULT_BUCKET_SIZE;
var bucketCount = Math.floor((maxValue - minValue)/ bucketSize)+1;
var buckets =newArray(bucketCount);for(i =0; i < buckets.length; i++){
buckets[i]=[];}// 利用映射函数将数据分配到各个桶中for(i =0; i < arr.length; i++){
buckets[Math.floor((arr[i]- minValue)/ bucketSize)].push(arr[i]);}
arr.length =0;for(i =0; i < buckets.length; i++){insertionSort(buckets[i]);// 对每个桶进行排序,这里使用了插入排序for(var j =0; j < buckets[i].length; j++){
arr.push(buckets[i][j]);}}return arr;}
基数排序(Radix Sort)
算法描述
取得数组中的最大数,并取得位数;
arr为原始数组,从最低位开始取每个位组成radix数组;
对radix进行计数排序(利用计数排序适用于小范围数的特点);
示例代码
var counter =[];
function radixSort(arr, maxDigit){
var mod =10;
var dev =1;for(var i =0; i < maxDigit; i++, dev *=10, mod *=10){for(var j =0; j < arr.length; j++){
var bucket =parseInt((arr[j]% mod)/ dev);if(counter[bucket]==null){
counter[bucket]=[];}
counter[bucket].push(arr[j]);}
var pos =0;for(var j =0; j < counter.length; j++){
var value = null;if(counter[j]!=null){while((value = counter[j].shift())!= null){
arr[pos++]= value;}}}}return arr;}