JavaScript的排序算法——冒泡排序

冒泡排序（Bubble Sort）

冒泡排序，有時也被稱做沉降排序，是一種比較簡單的排序算法。這種算法的實現是通過遍歷要排序的列表，把相鄰兩個不符合排列規則的數據項交換位置，然後重複遍歷列表，直到不再出現需要交換的數據項。當沒有數據項需要交換時，則表明該列表已排序。

中心思想：重複地走訪要排序的數列，一次比較兩個元素，如果它們的順序錯誤就把它們交換過來

算法描述：

1、比較相鄰的元素，如果第一個比第二個大，就交換它們

2、對每一對相鄰元素做同樣的工作，從開始第一對到結尾的最後一對，這樣在最後對元素就是最大的數

3、針對所有的元素，重複以上的步驟(除了最後一個)

4、重複步驟1～3，直到排序完成

                                                         

原理圖：

複雜度

算法	最好情況	平均情況	最壞情況	空間複雜度	穩定性
冒泡排序	O(n)	O(n2)	O(n2)	O(1)	穩定

 

代碼實現：

function bubbleSort(array){
	var len = array.length, result;
	result = array.slice(0);
	for (let i = 0; i < len; i++) {
		for (let j = 0; j <len-1; j++) {
			if (result[j] > result[j +1]) {
				var tmp = result[j + 1];
				result[j + 1] = result[j];
				result[j] = tmp;
			}
		}
	}
	return result;
}
console.log(bubbleSort([17,3,25,14，20,9]));

改進冒泡排序

對上述冒泡排序的一種優化， 優化思路：當一次遍歷前後數組不產生變化時，說明該數組已經有序，結束排序。

 

function bubbleSort(array){
	var len = array.length, result;
	result = array.slice(0);
	var exchange; //判斷數組排序內容是否有變化
	for (let i = 0; i < len; i++) {
		exchange = true;
		for (let j = 0; j <len-1; j++) {
			if (result[j] > result[j +1]) {
				var tmp = result[j + 1];
				result[j + 1] = result[j];
				result[j] = tmp;
				exchange = false;
			}
		}
		
		if(exchange){
			break;
		}
	}
	return result;
}
console.log(bubbleSort([17,3,25,14,20,9]));

冒泡排序優化2：

減小循環次數

function bubbleSort3(arr){
    let len = arr.length;
    for(let i = 0;i<len;i++){
        let exchange = true;
        for(let j = 0;j<len-1-i;j++){
            if(arr[j]>arr[j + 1]){
                [arr[j],arr[j+1]] = [arr[j+1],arr[j]];
                exchange = false;
            }
        }
        
        if(exchange){
            break;
        }
    }
    return arr;
}
console.log(bubbleSort3([17,3,25,14,20,9]));

 

冒泡排序優化3：

利用在每趟排序中進行正向和反向兩遍冒泡的方法，一次可以得到兩個最值(最大值和最小值)，從而使排序趟數幾乎減少一半。

function bubbleSort3(arr){
	var low = 0, high = arr.length-1;
	while(low<high){
		var j = low;
		for(j;j<high;j++){ // 正向冒泡找到最大值
			if(arr[j]>arr[j+1]){
				var temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
		}
		--high;
		for(j=high;j>low;j--){// 反向冒泡找到最小值
			if(arr[j]<arr[j-1]){
				var temp = arr[j];
				arr[j] = arr[j-1];
				arr[j-1] = temp;
			}
		}
		++low;
	}
	return arr;
}

冒泡優化4：

設置一個最大值標誌maxPos和最小值標誌minPos，每次只將兩個標誌之間的進行排序比較。

function bubbleSort4(arr){
	 var minPos = 0, maxPos = arr.length-1;
	 while(minPos<maxPos){
	     var j = minPos, tempMin, tempMax;
	     for(j;j<maxPos;j++){
	         if(arr[j]>arr[j+1]){
	             tempMax = j;
	             var temp = arr[j];
	             arr[j] = arr[j+1];
	             arr[j+1] = temp;
	         }
	     }
	     maxPos = tempMax;
	     for(j=maxPos;j>minPos;j--){
	         if(arr[j]<arr[j-1]){
	             tempMin = j;
	             var temp = arr[j];
	             arr[j] = arr[j-1];
	             arr[j-1] = temp;
	         }
	     }
	     minPos = tempMin;
	 }
	 return arr;
}

相關閱讀

JavaScript的排序算法——冒泡排序
JavaScript的排序算法——選擇排序
JavaScript的排序算法——插入排序
JavaScript的排序算法——歸併排序
JavaScript的排序算法——快速排序