js常用排序算法冒泡-選擇-插入-希爾

1冒泡排序：

沒什麼好說的，就是循環兩次，兩兩比較，先找到一個最大或最小的值，再找剩餘最大或最小的值，直到循環到最後；

先寫幾個公用方法：

/**
 * 數組初始化-隨機數
 */
function fnGetRandomArr(arrLength){
	var randomArr=[];
	for(var i=0;i<arrLength;i++){
		randomArr[i]=Math.floor(Math.random()*(arrLength+1));
	}
	return randomArr;
}

/**
 * 打印結果
 * @param {Object} arr
 */
function toString(arr){
	var restr="";
	for(var i=0;i<arr.length;i++){
		restr+=arr[i]+' ';
		if(i>0&&i%10==0){
			restr+='\n';
		}
	}
	return restr;
}

/**
 * 數組位置數值交換
 * @param {Object} arr
 * @param {Object} index1
 * @param {Object} index2
 */
function swap(arr,index1,index2){
	var temp=arr[index1];
	arr[index1]=arr[index2];
	arr[index2]=temp;
}

冒泡排序：

var count=1;
/**
 * 冒泡排序
 * @param {Object} dataStore
 */
function fnBubbleSort(dataStore){
	var length=dataStore.length;
	for(var outer=0;outer<length-1;outer++){
		for(var inner=outer+1;inner<length;inner++){
			if(dataStore[outer]>dataStore[inner]){
				count++;//互換次數
				swap(dataStore,outer,inner);
			}
		}
	}
}

結果:

結論：性能很一般；

2 選擇排序；

從冒泡排序的結果來看，在整個執行過程中，數組的值會出現大量的交換，而這是比較消耗性能的；選擇排序與冒泡排序方法差不多，區別在於，選擇排序是找的最小值或者最大值後，直接將這個值放到合適的位置上，中間不對數組進行“交換操作”；

/**
 * 選擇排序
 * @param {Object} dataStore
 */
function fnSelectionSort(dataStore){
	var length=dataStore.length;
	var min=0;
	var temp=0;
	for(var outer=0;outer<length-1;outer++){
		temp=dataStore[outer];
		min=outer;
		for(var inner=outer+1;inner<length;inner++){
			if(temp>dataStore[inner]){
				temp=dataStore[inner];
				min=inner;
			}
		}
		if(outer!=min){
			count++;
			swap(dataStore,outer,min);
		}
		
	} 
}

執行結果：

結論：可以看到"count"值明顯小了一些；

3 插入排序:

插入排序類似於打撲克時，放牌的動作。先抓了“方塊8”，然後是“紅桃4”，然後是“梅花7”，我們會整理成“紅桃4”、“梅花7”、“方塊8”類似這樣；

/**
 * 插入排序
 * @param {Object} dataStore
 */
function fnInsertonSort(dataStore){
	var length=dataStore.length;
	var min=0;
	var temp=0;
	for(var outer=1;outer<length;outer++){
		temp=dataStore[outer];
		min=outer;
		while(min>0&&(dataStore[min-1]>=temp)){
			dataStore[min]=dataStore[min-1];
			min--;
		}
		dataStore[min]=temp;
	}
}

執行結果：

 

4 希爾排序-插入排序升級版：

希爾排序可以理解爲插入排序的一個高級版本；區別在於它會先比較“較遠”的元素，然後在比較“較近”的元素；這樣就會盡快讓比較遠的元素回到合適的位置；而這樣做爲什麼就會提高效率，不妨拿支筆畫一畫好好感受感受；而每次比較多遠的值比較合適，

大佬Sedgewick給過一個公式：

var N=arr.length;
var h=1;
while(h<N/3){
    h=3*h+1;
}

//簡化下來
h=(h-1)/3;

/**
 * 希爾排序
 */
function fnShellSort(dataStore){
	var N=dataStore.length;
	var h=1;
	while(h<N/3){
		h=3*h+1;
	}
	while(h>=1){
		for(var outer=0;outer<N;outer++){
			for(var inner=outer;inner>=h&&dataStore[inner]<dataStore[inner-h];inner-=h){
				count++;
				swap(dataStore,inner,inner-h);
			}
		}
		h=(h-1)/3
	}
	
}

結果：

 

5 性能比較：

5.1冒泡排序：長度爲1w的隨機數據耗時大概是300ms;超過10w比較喫力；

5.2選擇排序：長度爲1w的隨機數據耗時大概是70ms;長度10w的數組大概在6.3秒；

5.3插入排序：長度爲1w的隨機數據耗時大概是30ms;長度10w的數組大概在3.3秒；

5.4希爾排序：長度爲1w的隨機數據耗時大概是6ms;長度10w的數組大概在30ms；;長度100w的數組大概在340ms；

js 數組 自身的排序

長度爲1w的隨機數據耗時大概是13ms;長度10w的數組大概在65ms；;長度100w的數組大概在700ms；