js排序（快速排序，插入排序， 堆排序）

插入排序，平均和最坏均为O（N ^ 2）,若已经预先排序好， 那么为O（N）
void Insertionsort(array)
{
var N = array.length;
for(var i = 1; i < N; i++)
{

var tmp = array[i];
//检测array[i]找到满足array[i] > array[i - 1]的, 不符合的前移, j > 0因为已经无可比较得了
for( var  j = i;j > 0 && aray[j - 1]  >  tmp;j--）
array[j] = array[j  - 1];	

array[j] = tmp;

}
}
N个互异数的平均逆序数N（N - 1）/ 4
由于相邻元素交换只减少一个逆序，故平均时间为O（N ^ 2）
for shellsort(array）
{
var N = array.length;
for(Increment = N / 2; Increment >= 1; Increment = Increment / 2 )
{

for(i = Increment; i < N ;i++)
{
tmp = array[i];
for( var j = i;j > Increment && array[j - Increment] > tmp; j -= Increment )
{
array[Increment] = array[j - Increment]
}
array[j] = tmp;

}
}

}
//使用1， 2 ^ N - 1的最坏时间能为O（N ^ 3 / 2）

堆: binary heap,complete binary tree;
由数组从左到右搞定；从1开始。任意节点的值小于其父节点的值。
通过上滤：在尾结点找到空穴 ，然后将不满足的父节点下移。
注意！对于二叉堆， N / 2 即为其父节点， 该性质极为有用。
Insert(element, heap)
{ //返回自增后的值
for(i = ++heap.length, i >1 && heap[i / 2] > element ,i = i / 2)
{
heap[i] = heap[i / 2]
}
heap[i] = element;
}
插入平均要用O(logN)时间；

通过DeleteMin操作进行排序
//直到找到能让last填进去的地方
functio DeleteMin(heap)
{
min = heap[1];
last = heap[heap.length–];
//保证有左儿子
for(i = 1;i * 2 <= heap.length;i = child)
{
//取比较小的儿子
child = 2 * i
if(child != heap.length && heap[child + 1] < heap[child])
child++;
if(last > H[child] )
H[i] = H[child]
else break;
}
H[i] = last;
H[++heap.length] = min;
}
resort()
平均耗时O（NlogN）

快速排序, 最好和平均O(NlogN)
qsort(array, , array.length - )
function qsort(array, left, right)
{
pivot = median(A, left, right)
i = left;
j = right - 1;
for(;?
{
while(array[++i] < pivot){}
while(array[–j] > pivot){}
if(i < j)
swap(array, i, j)
else
break;
}
swap(array, i, right);
qsort(array,left, i - 1);
qsort(array, i + 1, right);
}