冒泡排序详解

简介

一组数字，按从小到大排序，从左到右不断交换相邻的元素（如果右边小于左边的话），一次循环过后，最大的值在最右边了。演示如下图

示例

// typescript 示例
/**
 * 冒泡排序
 * @param {number[]} nums -需要排序的数组
 * @return {number[]} -返回排序后的数组
 */
function bubble(nums: number[]) {
	let len: number = nums.length;
	for (let i = len - 1; i > 0; i--) {
		for (let j = 0; j < i; j++) {
			// 如果j+1<j的话交换两个元素
			if (nums[j + 1] < nums[j]) {
				swap(nums, j, j + 1);
			}
		}
	}
	return nums;
}

/**
 * 交换数组中两个值
 * @param {number[]} nums -js中数组是引用类型
 * @param {number} i
 * @param {number} min
 */
function swap(nums:number[], i:number, min:number) {
	var swapValue = nums[i];
	nums[i] = nums[min];
	nums[min] = swapValue;
}

let nums:number[] = [4, 2, 11, 111, 5, 33, 21, 0, 55, 123, 1, 3];
console.log(bubble(nums));

优化

在一次循环中，如果没有发生交换，那么说明数组已经是有序的，此时可以直接退出循环。

/**
 * 冒泡排序
 * @param {number[]} nums -需要排序的数组
 * @return {number[]} -返回排序后的数组
 */
function bubble(nums: number[]) {
	let len: number = nums.length;
	let count: number = 0;
	for (let i = len - 1; i > 0; i--) {
		for (let j = 0; j < i; j++) {
			// 如果j+1<j的话交换两个元素
			if (nums[j + 1] < nums[j]) {
				swap(nums, j, j + 1);
			}
			console.log(++count);
		}
	}
	return nums;
}

function bubbleReview(nums: number[]) {
	let len: number = nums.length;
	let count: number = 0;
	let isSorted: boolean = false;
	for (let i = len - 1; i > 0 && !isSorted; i--) {
		isSorted = true;
		for (let j = 0; j < i; j++) {
			if (nums[j + 1] < nums[j]) {
				isSorted = false;
				swap(nums, j, j + 1);
			}
			console.log(++count);
		}
	}
	return nums;
}

/**
 * 交换数组中两个值
 * @param {number[]} nums -js中数组是引用类型
 * @param {number} i
 * @param {number} min
 */
function swap(nums:number[], i:number, min:number) {
	var swapValue = nums[i];
	nums[i] = nums[min];
	nums[min] = swapValue;
}

let nums:number[] = [4, 2, 11, 111, 5, 33, 21, 0, 55, 123, 1, 3];

console.log(bubble(nums));               // 优化前 循环次数66
console.log(bubbleReview(nums));   // 优化后 循环次数11