常见的排序

一、插入排序

折半查找

概念：折半查找，又称二分查找，它仅适用于有序的顺序表。

基本思想及查找步骤：

以low、middle和high表示待查区间的上界、中间位置和下界。low的初始值是0，high的初始值是length-1；

（1）让middle等于（low+high）/2的整数部分；

（2）比较中间位置记录的关键字与给定的K值：

a. 相等：查找成功

b. 大于：给定的K值在middle之前，并且让high = middle - 1，转到（1）

c. 小于：给定的K值在middle之后，并且让low = middle + 1，转到（1）

直到low>high，查找失败。

//折半查找
/*
 参数array：待查区间（有序）；item：待查记录
 查询成功，返回item在array的位置；查询失败，返回-1
*/
function binarySearch(array, item){
	var low = 0,
        high = array.length - 1,
	    middle = Math.floor((low+high)/2);
	var result = -1;
	while(low <= high){
		if(array[middle] == item){
	    	result = middle;
		    break;
		} else if(array[middle] > item){//“>”表示array是升序，“<”表示array是降序
			high = middle - 1;
		} else{
			low = middle + 1;
		}
		middle = Math.floor((low + high) / 2);
	}
	return result;
}

折半插入排序

当将待排序的记录R[i]插入到已排好序的记录子表R[0...i-2]中时，由于R0，R1，...，Ri-2已排好序，则查找插入位置可以用“折半查找”实现。于是，折半插入排序与直接插入排序相比，只是在查找插入位置上不同，折半查找减少了比较原始的次数。

//折半插入排序
function binary_insert_sort(array){
	var result = [];
	result.push(array[0]);
	for(var i = 1; i < array.length; i++){
		var low = 0,
			high = result.length - 1;
			middle = Math.floor((low + high) / 2);
		//寻找插入的位置
		while(low <= high){
			if(array[i] >= result[middle]){//“>=”表示升序，“<=”表示降序
				low = middle + 1;
			} else {
				high = middle - 1;
			}
			middle = Math.floor((low + high) / 2);
		}
		//插入数据
		result.splice(high+1, 0, array[i]);
	}
	return result;
}

希尔排序

希尔排序，又称缩小增量法，是一种分组插入排序。

排序思想：

（1）先取一个正整数d1（d1<n,n为待排记录的个数）作为第一个增量，将n个记录分为d1个组（把所以相隔d1的记录放在同一个组中），然后在各个组内进行直接插入排序，这样一次分组和排序过程称为一趟希尔排序；

第一组：（0,0+d1,0+2d2, ...）

第二组：（1,1+d1,1+2d1,...）

......

（2）取新的增量d2<d1，重复（1）。直到所去增量d=i为止。

二、交换排序

冒泡排序

排序思想：

       假设待排序表长为n，从后往前（或从前往后）两两比较相邻元素的值，若为逆序（前一个元素大于后一个元素），则交换它们，直到序列比较完，我们称之为一趟冒泡。每趟冒泡分别是将让最小的元素、次小的元素……浮出“水面”。

       具体来说，

      （1）若从后往前排，如果是升序/降序，则第一趟排序后，待排序表中最小/最大的元素就位于表中第一个位置了，第二趟排序后，待排序表中次小/次大的元素就位于表中第二个位置了。

      （2）若从前向后排，如果是升序/降序，则第一趟排序后，待排序表中最小/最大的元素就位于表中最后位置了，第二趟排序后，待排序表中次小/次大的元素就位于表中倒数二个位置了。

       这样，最多会进行n-1趟排序。

var array = [30, 13, 70, 85 ,39, 42, 6, 20];

//冒泡排序
function bubbleSort(array){
	for(var i = 0; i < array.length - 1; i++){//冒泡次数
		for(var j = array.length - 1; j >= i ; j--){//设置从后往前或从前向后，这里是从后往前
	    // for(var j = 0; j < array.length - i; j++){ //从前向后
			if(array[j-1] > array[j]){//设置升序或降序，这里是升序
				var temp = array[j-1];
				array[j-1] = array[j];
				array[j] = temp;
			}
		}
		console.log("第"+ (i+1) + "趟：" + array.join(", "));
	}
	return array;
}

console.log("最后的结果："+bubbleSort(array).join(", "));

从后往前，升序的结果如下图：

快速排序

排序思想：

在待排序表L[0...n-1]中任选一个元素作为基准元素pivot，通过一趟排序将待排表划分为两部分，其中L[0...k-1]中的元素全都小于pivot，L[k+1...n-1]中的元素全都大于pivot。而pivot这个元素就放在L[k]中，k就是pivot元素的最终位置。

//快速排序
function quickSort_recursive(array, low, high){
	if(low<high){
		var pos = partition(array, low, high);
		quickSort_recursive(array,low, pos-1);
		quickSort_recursive(array,pos+1,high);
	}
	return array;
}

//一趟快排
function partition(array, low, high){
	var pivot = array[low];
	while(low < high){
		while(low<high && array[high] >= pivot){
			--high;
		}
		array[low] = array[high];
		while(low<high && array[low] <=pivot){
			++low;
		}
		array[high] = array[low]
	}
	array[low] = pivot;
	return low;
}

console.log(quickSort_nonRecursive(array,0, array.length-1));

三、选择排序

简单选择排序

排序思想：

假设待排序表为L[0...n-1]，第i趟排序即从表L[i-1...n-1]关键字最小的元素与L[i-1]交换。每一趟排序可以确定一个元素的最终位置。总共需要进行n-1趟排序。

function selectSort(array){
	for(var i = 0; i < array.length-1; i++){ //排序次数
		var min = i;
		for(var j = i + 1 ; j < array.length; j++){
			if(array[min] > array[j]){
				min = j;
			}
		}
		if(i != min){
			var temp = array[i];
			array[i] = array[min];
			array[min] = temp;
		}
	}
}
var array = [30, 13, 70, 85 ,39, 42, 6, 20];
selectSort(array);
console.log(array);

堆排序

堆排序，又称树形选择排序。

堆的定义：n个关键字序列L[1...n]称为堆，当且仅当该序列满足：

（1）L(i)<=L(2i)且L(i)<=L[2i+1]，或者

（2）L(i)>=L(2i)且L(i)>=L[2i+1]

满足（1），称为小根堆（小顶堆）；满足（2），称为大根堆（大顶堆）。

除此之外，堆还有以下性质：

（1）堆是一棵采用顺序存储结构的完全二叉树；

（2）堆中的任一子树也是堆。

一般来说，升序选择大根堆，降序选择小根堆。且形成一次堆只能找到最大或最小的元素。每完成一次堆排序，就将根元素与最后一个叶子结点交换，交换后的最后一个叶子结点不再参与排序。

堆排序主要需要解决两个问题：

（1）如何从一个无序列表建成一个堆；

（2）如何在输出堆顶元素后，调整剩余元素，使之成为一个新的堆。

对于问题（1），一个无序列表按顺序形成一棵完全二叉树时可能并不堆的性质，因此需要调整这棵完全二叉树。这样看来，问题（1）、（2）面临的共同问题就是如何调整完全二叉树，使之满足堆的性质。

// 给定一个序列array，用array来生成一个大根堆
function buildMaxHeap(array, len){
	for(var i = Math.floor(len/2) - 1; i >= 0; i--){
		adjustDown(array, i, len);
	}
}

//从上到下调整为大根堆
function adjustDown(array, k, len){
	var temp = array[k];
	for(var i = 2*k+1; i < len; i = i*2+1){
		if(i+1 < len && array[i] < array[i+1]){
			i++;
		}
		if(temp >= array[i]){
			break;
		} else {
			array[k] = array[i];
			k = i;
		}
	}
	array[k] = temp;
}

function heapSort(array){
	// 建立大根堆
	buildMaxHeap(array, array.length);
	for(var i = array.length-1; i > 0; i--){//排序次数
		//交换元素
		var temp = array[0];
		array[0] = array[i];
		array[i] = temp;
		//再次调整为大根堆
		adjustDown(array, 0, i);
	}
}
// 测试
var a = [53,17,78,9,45,65,87,32];
heapSort(a);
console.log(a);

2-路归并排序

排序思想：

将两个或两个以上的有序表合成一个新的有序表。假设待排序表含有n个记录，则可以看成是n个有序的子表，每个子表长度为1，然后两两归并，得到n/2+1个长度为2或1的有序表；再两两归并，......如此重复，直到合成一个长度为n的有序表为止。

递归代码如下（JavaScript）：

var merge = function(array, low, mid, high){
	var temp = array.concat([]);
	for(var i = low, j =  mid+1, k = i; i <= mid && j <= high; k++){
		if(temp[i] <= temp[j]){
			array[k] = temp[i++];
		} else {
			array[k] = temp[j++];
		}
	}
	while(i<=mid){
		array[k++] = temp[i++];
	}
	while(j<=high){
		array[k++] = temp[j++];
	}
},
var mergeSort = function(array, low, high){
	if(low<high){
		var mid = Math.floor((low+high)/2);
		mergeSort(array, low, mid);
		mergeSort(array, mid+1, high);
		merge(array, low, mid, high);
	}
}
var array = [49,38,65,97,76,13,27];
mergeSort(array);
console.log(array);

非递归代码如下：

var merge = function(array, low, mid, high){
	var temp = array.concat([]);
	for(var i = low, j =  mid+1, k = i; i <= mid && j <= high; k++){
		if(temp[i] <= temp[j]){
			array[k] = temp[i++];
		} else {
			array[k] = temp[j++];
		}
	}
	while(i<=mid){
		array[k++] = temp[i++];
	}
	while(j<=high){
		array[k++] = temp[j++];
	}
}
// 两两归并
var merge_pass = function(array, d){

	var j = 0;
	var len = array.length;
	while(j+2*d-1 < len){
		this.merge(array, j, j+d-1, j+2*d-1);
		j = j + 2*d;
	}
	if(j+d-1 < len){
		this.merge(array, j, j+d-1, len-1);
	} else {
		this.merge(array, j, len-1, len-1);
	}
}

var merge_sort = function(array){
	var d = 1;
	while(d < array.length){
		this.merge_pass(array,d);
		this.merge_pass(array,2*d);
		d = 4*d;
	}
}
var array = [49,38,65,97,76,13,27];
merge_sort(array);
console.log(array);