常见的基本排序算法

1.冒泡排序

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

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

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

d.重复a-c,直到排序完成

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;
}

2.选择排序

工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。 

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;
} 

3.插入排序

工作原理是通过构建有序序列，以有序序列为标准，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

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;
}

4.希尔排序

是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

 

5.归并排序

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

算法描述

• 把长度为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);   // 分割左右部分
    return merge(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;
}

6.快速排序

通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

算法描述

• 从数列中挑出一个元素，称为 “基准”（pivot）；
• 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
• 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

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;
}

7.堆排序

利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。