一篇文章搞定javascript冒泡排序

從今天開始講述關於javascript的排序

冒泡排序

冒泡排序是最慢的排序算法之一，但也是最容易實現的排序算法。 之因此叫冒泡排序是由於這種算法在排序時，數據值會像氣泡同樣從數組的一端漂浮到另外一端，假設正在將一組數字按照升序排列，較大的值會浮動到數組的右側，較小的值會浮動到數組的左側，之因此會產生這種現象是由於算法會屢次在數組中移動，比較相鄰的數據，當左側的值大於右側的值時，將他們進行互換。

一個簡單的🌰： E A D B H 通過第一次排序後： A E D B H 第一個和第二個元素進行了互換

通過第二次排序： A D E B H 第二個和第三個進行了互換

通過第三次排序： A D B E H 第三個和第四個進行了互換

最後，第二個和第三個再次進行互換，獲得最終順序： A B D E H 一張圖片描述的很形象

準備工做，造數據

咱們先準備一組隨機數據，用來排序使用 要求：

• 數組
• 整數（0-100）

let arr = []

function arrData(num) {
	for (let i = 0; i < num; i++) {
		arr[i] = Math.floor(Math.random() * num + 1)
	}
}
arrData(100)
console.log(arr);
複製代碼

利用sort冒泡排序

arr = arr.sort(function (a, b) {
	return a - b
});
console.log(arr); 
複製代碼

經過添加中間變量實現冒泡排序

function sortarr(myArr) {
	for (let i = 0; i < myArr.length - 1; i++) {
		for (let j = 0; j < myArr.length - 1; j++) {
			if (myArr[j] > myArr[j + 1]) {
				let temp = myArr[j];
				myArr[j] = arr[j + 1];
				myArr[j + 1] = temp;
			}
		}
	}
	return myArr;
}
let arr1 =   sortarr(arr)
console.log(arr1);
複製代碼

輸出結果是同樣的

不經過添加中間變量實現冒泡排序

不使用中間變量，算法原型以下：（不使用第三個變量，互換兩個元素）

a = 10; //第一個元素
b = 5; //下一個元素
if (a > b) {
	a = a + b; // a(15) = 10 +5;
	b = a - b; // b(10) = 15 - 5;
	a = a - b; // a(5) = 15 - 10;
}
複製代碼

冒泡排序以下：

function jssort(myArr) {
	for (let i = 0; i < myArr.length-1; i++) { //要循環多少次
		for (let j = 0; j < myArr.length  - 1; j++) { //要移動幾回
			if (myArr[j] > myArr[j + 1]) {
				myArr[j] = myArr[j] + myArr[j + 1]; //a = a+b 
				myArr[j + 1] = myArr[j] - myArr[j + 1]; //b = a-b
				myArr[j] = myArr[j] - myArr[j + 1]; //a = a-b
			}
		}
	}
	return myArr;
}
複製代碼

經過es6，能夠實現一樣的效果 算法原型：

let arr1 = [1,3]
[1,3]=[3,1]
console.log(arr1);//=> [3, 1]
複製代碼

排序

function jssort(myArr) {
	for (let i = 0; i < myArr.length-1; i++) { //要循環多少次
		for (let j = 0; j < myArr.length  - 1; j++) { //要移動幾回
			if (myArr[j] > myArr[j + 1]) {
				[myArr[j] , myArr[j + 1]]=[myArr[j+1] , myArr[j]]
			}
		}
	}
	return myArr;
}
複製代碼

冒泡排序的一次優化

咱們以前的數組的長度是100，不利於觀察，咱們聲明一個簡單一點的數組

var arr = [65, 39, 28, 11, 10, 3];
function jssort(myArr) {
	for (let i = 0; i < myArr.length - 1; i++) { //要循環多少次
		console.log(`第${i}次`);
		for (let j = 0; j < myArr.length - 1; j++) { //要移動幾回
			if (myArr[j] > myArr[j + 1]) {
				[myArr[j], myArr[j + 1]] = [myArr[j + 1], myArr[j]]
			}
			console.log(arr);
		}
	}
	return myArr;
}
console.log(jssort(arr));
複製代碼

看下輸出：

兩層for循環，當i=0的時候，裏面的循環完整執行，從j=0執行到j=5,這也就是第一遍排序，結果是將最大的數排到了最後

當i=1的時候，裏面的循環再次完整執行，因爲最大的數已經在最後了，沒有必要去比較數組的最後兩項，因此能夠作一下優化：

var arr = [65, 39, 28, 11, 10, 3];
function jssort(myArr) {
	for (let i = 0; i < myArr.length - 1; i++) { //要循環多少次
		console.log(`第${i}次`);
		for (let j = 0; j < myArr.length - 1 - i; j++) { //要移動幾回
			if (myArr[j] > myArr[j + 1]) {
				[myArr[j], myArr[j + 1]] = [myArr[j + 1], myArr[j]]
			}
			console.log(arr);
		}
	}
	return myArr;
}
console.log(jssort(arr));
複製代碼

第一次執行，找到最大的，並放在數組的左端 第二次執行，找到了第二大的，放在了作起第二的位置， 因此,內層循環能夠作以下優化，當數據量很大的時候，顯得尤其重要

for (let j = 0; j < myArr.length - 1 - i; j++) {
	//....
}
複製代碼

好了，關於javascript冒泡排序就講到這裏了，明天咱們繼續討論js排序的其餘算法

原文連接