排序算法可以分为内部排序和外部排序。内部排序是数据记录在内存中进行排序，外部排序是因排序的数据很大，一次不能够容纳全部的排序记录，在排序中需要访问外存。常见的内部排序算法有插入排序，选择排序，冒泡排序，归并排序，快速排序，堆排序。
算法一：插入排序
算法步骤：
1.将第一待排序序列第一个元素看做一个有序数列，把第二个元素到最后一个元素当做未排序序列。
2.从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列适当位置中（如果待插入的元素与有序数列中的某个元素相等，则待插入元素插入到相等元素的后面）
例如：19 2 8 11 24 6
2 19
2 8 19
2 8 11 19
2 8 11 19 24
2 6 8 11 19 24
代码实现：
var arr=[77,56,3,8,4];
function compare(arr){
var newArr=[];
newArr.push(arr[0]);//77
for(var i=1;i<arr.length;i++){
newArr.push(arr[i]);//56---77 56
for(var j=newArr.length-2;j>=0;j--){
if(newArr[j+1]<newArr[j]){
var temp = newArr[j];
newArr[j] = newArr[j+1];
newArr[j+1] = temp;//56 77
}
}
}
console.log(newArr);
}
compare(arr);
算法二：冒泡排序
算法步骤：
1.比较相邻的元素，如果第一个比第二个大，就交换他们两个
2.对每一对相邻的元素作同样的工作，从开始第一对到结尾的最后一对，这步做完后，最后的元素会是最大的数
3.针对所有的元素重复以上步骤，除了最后一个
4.持续对每次越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较
代码示例：
var a=[38,9,2,14,6];
for(var i=0;i<a.length;i++){
for(var j=0;j<a.length-1;j++){
if(a[j+1]>a[j]){
a[j]=a[j]+a[j+1];
a[j+1]=a[j]-a[j+1];
a[j]=a[j]-a[j+1];
}
}
console.log(a[i]);
}
算法三：快速排序
算法步骤：
1.从数列中挑出一个元素，称为基准
2.重新排序数列，所有元素比基准值小的摆放在基准前面，所有愿所有比基准值大的摆在基准的后面（相同的数可以到任意一边），在这个分区退出之后，该基准就处于数列的中间位置，这个称之为分区操作。
3.递归的把所有小于基准值元素的子数列和大于基准值元素的子数列排序
递归的最底部情形是数列的大小是0或1，也就是永远都已经被排序好了，虽然一直递归下去，但这个方法总会退出，因为在每次的迭代中，它至少把一个元素摆到它最后的位置去。
代码示例：
function qSort(a,left,right){
var mid = a[left];
while(left<right){
while(a[right]>mid&&left<right)right--;
if(left<right)
a[left++]=a[right];
while(a[left]<mid&&left<right) left++;
if(left<right)
a[right--]=a[left];
}
a[left] = mid;
return left;
}
function quickSort(a,left,right){
if(left<right){
var mid = qSort(a,left,right);
quickSort(a,left,mid-1);
quickSort(a,mid+1,right);
}
}
var a=[25,79,44,11,36,42,8];
quickSort(a,0, a.length-1);
for(var i=0; i< a.length;i++){
console.log(a[i]);
}
算法四：堆排序
算法步骤：
1.创建一个堆
2.把堆首和堆尾互换
3.把堆的尺寸缩小1，并调用shift-down(0),目的是把新的数组顶端数据调整到相应的位置
4.重复步骤2，直到堆的尺寸为1
代码示例：
function headAdjust(elements, pos, len){
var swap = elements[pos];
var child = pos * 2 + 1;
while(child < len){
if(child + 1 < len && elements[child] < elements[child + 1]){
child += 1;
}
if(elements[pos] < elements[child]){
elements[pos] = elements[child];
pos = child;
child = pos * 2 + 1;
}
else{
break;
}
elements[pos] = swap;
}
}
function buildHeap(elements){
for(var i=elements.length/2; i>=0; i--){
headAdjust(elements, i, elements.length);
}
}
function sort(elements){
buildHeap(elements);
for(var i=elements.length-1; i>0; i--){
var swap = elements[i];
elements[i] = elements[0];
elements[0] = swap;
headAdjust(elements, 0, i);
}
}
var elements = [33, 17, 25, 77, 42, 24, 59, 16, 1, 38];
sort(elements);
console.log(elements);
算法五：归并排序
算法步骤：
1.申请空间，使其大小为两个排序序列之和，该空间用来存放合并后的数列
2.设定两个指针，最初位置分别是两个已经排序序列的起始位置
3.比较两个指针所指向的元素，选择相对小的元素放到合并空间，并移动指针到下一位置
4.重复步骤3直到某一指针达到序列尾
5.将另一序列剩下的所有元素直接复制到合并序列尾
代码示例：
function mergeSort(arr){
if(arr.length<2){
return arr;
}
var middle = Math.floor(arr.length/2);
var left = arr.slice(0,middle);
var right = arr.slice(middle,arr.length);
return merge(mergeSort(left),mergeSort(right));
}
function merge(left,right){
var newArr = [];
while(left.length&&right.length){
if(left[0] <= right[0]){
newArr.push(left.shift());
}else{
newArr.push(right.shift());
}
}
while(left.length){
newArr.push(left.shift());
}
while(right.length){
newArr.push(right.shift());
}
return newArr;
}
var arr = [14,88,41,6,45,21];
console.log(mergeSort(arr));
算法六：选择排序
算法步骤：
1.首先在未排序序列中找到最大或最小元素，存放到序列起始位置
2.再从剩余序列中找到最大或最小元素放到已排序序列末尾
3.重复第二步，直到所有元素都排序完毕
代码示例：
function choseSort(a){
for(var j=0;j< a.length-1;j++){
var index = j;
for(var i=j;i< a.length;i++){
if(a[i]<a[index]){
index = i;
}
}
var temp = a[j];
a[j] = a[index];
a[index] = temp;
}
return a[j];
}
var a = [15,2,41,30,9,14];
choseSort(a);
for(var i=0;i< a.length;i++){
console.log(a[i]);
}