8 十大排序算法比较 #

function bubbleSort(arr) {
	console.time('改进前冒泡排序耗时')
	if (arr.length <= 1) return
	//1. 确定循环多少次
	for (let i = 0; i < arr.length - 1; i++) {
		//2. 循环起始点 每次循环j与后一位进行比较 大于则调换位置
		for (let j = 0; j < arr.length - i - 1; j++) {
			if (arr[j] > arr[j + 1]) {
				;[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]
			}
		}
	}
	console.timeEnd('改进前冒泡排序耗时')
}
//优化版本 当某次冒泡操作已经没有数据交换时，说明已经达到完全有序，不用再继续执行后续的冒泡操作。
function bubbleSort1(arr) {
	console.time('改进后冒泡排序耗时')
	if (arr.length <= 1) return
	//1. 确定循环多少次
	for (let i = 0; i < arr.length - 1; i++) {
		// 确定内层循环是否是有序
		let hasChange = false
		//2. 循环起始点 每次循环j与后一位进行比较 大于则调换位置
		for (let j = 0; j < arr.length - i - 1; j++) {
			if (arr[j] > arr[j + 1]) {
				;[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]
				hasChange = true
			}
		}
		//如果有序直接跳出当前循环
		if (!hasChange) break
	}
	console.timeEnd('改进后冒泡排序耗时')
}

//测试
const arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
bubbleSort(arr) //改进前冒泡排序耗时: 0.106ms
bubbleSort1(arr) //改进后冒泡排序耗时: 0.006ms

function insertionSort(arr) {
	console.time('快速排序耗时')
	const len = arr.length
	if (len <= 1) return
	// 每次比较元素的的索引 和当前元素的值
	let preIndex, current
	// 初始值定在数组第二个数
	for (let i = 1; i < len; i++) {
		//定义索引起始值
		preIndex = i - 1
		//定义第一个比较的数为第二个数
		current = arr[i]
		//当前索引大于等于0 说明对比完成 并且当前的数比之前的索引数值小才一直往前移动
		while (preIndex >= 0 && current < arr[preIndex]) {
			// 如果arr[preIndex]>current 移动过程中,不断的将前一个值赋值给后一个值
			// 例如 [1,5,6,4] current=4 ==> preIndex:2 6赋值给4 [1,5,6,6] ==> preIndex:1 接着比较 [1,5,5,6] ==> preIndex:0 不满足current<arr[preIndex] 跳出循环 ==>  将preIndex+1 位置赋值为current值
			arr[preIndex + 1] = arr[preIndex]
			preIndex--
		}
		//跳出循环后，说明找到一个值arr[preIndex] 比我current值小  将current值赋值给preIndex+1
		arr[preIndex + 1] = current
	}

	console.timeEnd('快速排序耗时')
}
function insertionSort1(arr) {
	console.time('快速排序耗时')
	const len = arr.length
	if (len <= 1) return
	// 初始值定在数组第二个数
	for (let i = 1; i < len; i++) {
		//定义索引起始值
		preIndex = i - 1
		//定义第一个比较的数为第二个数
		current = arr[i]
		//当前索引大于等于0 说明对比完成 并且当前的数比之前的索引数值小才一直往前移动
		while (preIndex >= 0 && current < arr[preIndex]) {
			preIndex--
		}
		//使用splice方法 不需要里面的两个赋值语句
		//跳出循环后，说明找到一个值arr[preIndex] 比我current值小
		//插入到preIndex索引后
		//删除原current的值
		arr.splice(i, 1)
		arr.splice(preIndex + 1, 0, current)
	}

	console.timeEnd('快速排序耗时')
}

//测试
const arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
insertionSort(arr) //快速排序耗时: 0.075ms
insertionSort1(arr) //快速排序耗时: 0.188ms

function selectionSort(arr) {
	console.time('选择排序耗时')
	let len = arr.length
	let minIndex, temp
	for (let i = 0; i < len; i++) {
		//先定义最小的索引
		minIndex = i
		// 遍历找出最小的值保存索引
		for (j = i + 1; j < len; j++) {
			if (arr[minIndex] > arr[j]) {
				minIndex = j
			}
		}
		//获取到最小值索引，与当前的索引进行位置互换
		// [arr[minIndex], arr[i]] = [arr[i], arr[minIndex]]
		temp = arr[minIndex]
		arr[minIndex] = arr[i]
		arr[i] = temp
	}
	console.timeEnd('选择排序耗时')
}

//测试
const arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
selectionSort(arr) //选择排序耗时: 0.099ms

function shellSort(arr) {
	console.time('希尔排序耗时')
	let len = arr.length
	let gap = 1
	let temp
	// 定义动态间隔序列 3
	while (gap < len / 3) {
		gap = gap * 3 + 1
	}
	for (gap; gap > 0; gap = Math.floor(gap / 3)) {
		for (let i = gap; i < len; i++) {
			temp = arr[i]
			let j = i - gap
			for (; j >= 0 && arr[j] > temp; j -= gap) {
				arr[j + gap] = arr[j]
			}
			arr[j + gap] = temp
		}
	}

	console.timeEnd('希尔排序耗时')
}
//测试
const arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
shellSort(arr) //希尔排序耗时: 0.078ms

function quickSort(arr) {
	if (arr.length <= 1) return arr
	//取基准点
	const midIndex = Math.floor(arr.length / 2)
	//取基准点的值，并删除原数组的值
	const valArr = arr.splice(midIndex, 1)
	const midIndexVal = valArr[0]
	//定义存放左右的数组
	const left = []
	const right = []
	//遍历数组 进行判断分配
	for (let i = 0; i < arr.length; i++) {
		if (arr[i] < midIndexVal) {
			left.push(arr[i]) //比基准点小的放在左边数组
		} else {
			right.push(arr[i]) //比基准点大的放在右边数组
		}
	}
	//递归执行以上操作，对左右两个数组进行操作，直到数组长度为 <= 1
	return quickSort(left).concat(midIndexVal, quickSort(right))
}

// 快速排序
const quickSort1 = (arr, left, right) => {
	let len = arr.length,
		partitionIndex
	left = typeof left != 'number' ? 0 : left
	right = typeof right != 'number' ? len - 1 : right

	if (left < right) {
		partitionIndex = partition(arr, left, right)
		quickSort1(arr, left, partitionIndex - 1)
		quickSort1(arr, partitionIndex + 1, right)
	}
	return arr
}

const partition = (arr, left, right) => {
	//分区操作
	let pivot = left, //设定基准值（pivot）
		index = pivot + 1
	for (let i = index; i <= right; i++) {
		if (arr[i] < arr[pivot]) {
			swap(arr, i, index)
			index++
		}
	}
	swap(arr, pivot, index - 1)
	return index - 1
}

const swap = (arr, i, j) => {
	let temp = arr[i]
	arr[i] = arr[j]
	arr[j] = temp
}

//测试
const arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
console.time('快速排序耗时')
quickSort(arr) //快速排序耗时: 0.137ms
quickSort1(arr) //快速排序耗时: 0.118ms
console.timeEnd('快速排序耗时')

// 快速排序  原地快排
//    i->       <-j
// [d,a,b,c,e,f,g,h]
// i找到一个比e大的
// j找到一个比e小的
// i和j交换位置
// 最后i和j遇见

function quick1(arr, start, end) {
	// 双指针
	//先存储start索引
	let init = start
	//定义start为标记位
	let flag = arr[init]
	// start++  1 此处+1 是因为后面end需要找一个比flag小的数 但是不能遍历到init 0 这个位置
	start++
	while (start <= end) {
		//一直遍历出小于flag的end索引
		while (arr[end] > flag) {
			end--
		}
		//遍历出大于flag的start索引
		while (arr[start] < flag) {
			start++
		}
		// 到了这一步说明找到了满足上述条件的start和end
		//如果start 小于end索引 进行交换
		if (start < end) {
			;[arr[start], arr[end]] = [arr[end], arr[start]]
			start++
			end--
		}
	}
	//遍历完没有找到对应索引 将起始位置索引 与遍历后start-1 索引进行互换位置
	;[arr[init], arr[start - 1]] = [arr[start - 1], arr[init]]
	return start
}

function quickSort1(arr, start, end) {
	// 默认start是0 end是最后一个元素
	//如果start小于end进行快排
	if (start < end) {
		let index = quick1(arr, start, end) //标志位的值
		quickSort1(arr, start, index - 1)
		quickSort1(arr, index, end)
	}
	return arr
}

//核心思想:定义起始位置0，0先进行排序 找出arr[0]    使用i进行右移找出大于arr[0],j向左移动找出小于arr[0]，如果找出了先判断start是不是小于end 是的话进行互换。
//不是的则将当前0位置与start-1位置进行互换位置

//测试
// const arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
const arr = [2, 1, 3]
// quickSort(arr) //堆排序耗时: 0.103ms

console.time('快速排序')
console.log('打印***', quickSort1(arr, 0, arr.length - 1))
console.timeEnd('快速排序')

function mergeSort(arr) {
	//采用自上而下的递归方法
	const len = arr.length
	if (len < 2) {
		return arr
	}
	// length >> 1 和 Math.floor(len / 2) 等价
	let middle = Math.floor(len / 2),
		left = arr.slice(0, middle),
		right = arr.slice(middle) // 拆分为两个子数组
	return merge(mergeSort(left), mergeSort(right))
}

function merge(left, right) {
	const result = []
	while (left.length && right.length) {
		// 注意: 判断的条件是小于或等于，如果只是小于，那么排序将不稳定.
		if (left[0] <= right[0]) {
			result.push(left.shift())
		} else {
			result.push(right.shift())
		}
	}
	while (left.length) result.push(left.shift())
	while (right.length) result.push(right.shift())
	return result
}

//测试
const arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
console.time('归并排序耗时')
mergeSort(arr) //归并排序耗时:  0.128ms
console.timeEnd('归并排序耗时')

// 堆排序
const heapSort = array => {
	console.time('堆排序耗时')
	// 初始化大顶堆，从第一个非叶子结点开始
	for (let i = Math.floor(array.length / 2 - 1); i >= 0; i--) {
		heapify(array, i, array.length)
	}
	// 排序，每一次 for 循环找出一个当前最大值，数组长度减一
	for (let i = Math.floor(array.length - 1); i > 0; i--) {
		// 根节点与最后一个节点交换
		swap(array, 0, i)
		// 从根节点开始调整，并且最后一个结点已经为当前最大值，不需要再参与比较，
		//所以第三个参数为 i，即比较到最后一个结点前一个即可
		heapify(array, 0, i)
	}
	console.timeEnd('堆排序耗时')
	return array
}

// 交换两个节点
const swap = (array, i, j) => {
	let temp = array[i]
	array[i] = array[j]
	array[j] = temp
}

// 将 i 结点以下的堆整理为大顶堆，注意这一步实现的基础实际上是：
// 假设结点 i 以下的子堆已经是一个大顶堆，heapify 函数实现的
// 功能是实际上是：找到 结点 i 在包括结点 i 的堆中的正确位置。
// 后面将写一个 for 循环，从第一个非叶子结点开始，对每一个非叶子结点
// 都执行 heapify 操作，所以就满足了结点 i 以下的子堆已经是一大顶堆
const heapify = (array, i, length) => {
	let temp = array[i] // 当前父节点
	// j < length 的目的是对结点 i 以下的结点全部做顺序调整
	for (let j = 2 * i + 1; j < length; j = 2 * j + 1) {
		temp = array[i] // 将 array[i] 取出，整个过程相当于找到 array[i] 应处于的位置
		if (j + 1 < length && array[j] < array[j + 1]) {
			j++ // 找到两个孩子中较大的一个，再与父节点比较
		}
		if (temp < array[j]) {
			swap(array, i, j) // 如果父节点小于子节点:交换；否则跳出
			i = j // 交换后，temp 的下标变为 j
		} else {
			break
		}
	}
}

//测试
const arr = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
heapSort(arr) //堆排序耗时: 0.103ms

const countingSort = array => {
	let len = array.length,
		result = [],
		countArr = [],
		min = (max = array[0])
	console.time('计数排序耗时')
	for (let i = 0; i < len; i++) {
		// 获取最小，最大 值
		min = min <= array[i] ? min : array[i]
		max = max >= array[i] ? max : array[i]
		countArr[array[i]] = countArr[array[i]] ? countArr[array[i]] + 1 : 1
	}
	console.log('countArr :', countArr)
	// 从最小值 -> 最大值,将计数逐项相加
	for (let j = min; j < max; j++) {
		countArr[j + 1] = (countArr[j + 1] || 0) + (countArr[j] || 0)
	}
	console.log('countArr 2:', countArr)
	// countArr 中,下标为 array 数值，数据为 array 数值出现次数；反向填充数据进入 result 数据
	for (let k = len - 1; k >= 0; k--) {
		// result[位置] = array 数据
		result[countArr[array[k]] - 1] = array[k]
		// 减少 countArr 数组中保存的计数
		countArr[array[k]]--
		// console.log("array[k]:", array[k], 'countArr[array[k]] :', countArr[array[k]],)
		console.log('result:', result)
	}
	console.timeEnd('计数排序耗时')
	return result
}
const array = [2, 2, 3, 8, 7, 1, 2, 2, 2, 7, 3, 9, 8, 2, 1, 4, 2, 4, 6, 9, 2]
console.log('原始 array: ', array)
const newArr = countingSort(array)
console.log('newArr: ', newArr)
// 原始 array:  [2, 2, 3, 8, 7, 1, 2, 2, 2, 7, 3, 9, 8, 2, 1, 4, 2, 4, 6, 9, 2]
// 计数排序耗时:   5.6708984375ms
// newArr:  	 [1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 4, 4, 6, 7, 7, 8, 8, 9, 9]

const countingSort2 = (arr, maxValue) => {
	console.time('计数排序耗时')
	maxValue = maxValue || arr.length
	let bucket = new Array(maxValue + 1),
		sortedIndex = 0
	;(arrLen = arr.length), (bucketLen = maxValue + 1)

	for (let i = 0; i < arrLen; i++) {
		if (!bucket[arr[i]]) {
			bucket[arr[i]] = 0
		}
		bucket[arr[i]]++
	}

	for (let j = 0; j < bucketLen; j++) {
		while (bucket[j] > 0) {
			arr[sortedIndex++] = j
			bucket[j]--
		}
	}
	console.timeEnd('计数排序耗时')
	return arr
}
const array2 = [2, 2, 3, 8, 7, 1, 2, 2, 2, 7, 3, 9, 8, 2, 1, 4, 2, 4, 6, 9, 2]
console.log('原始 array2: ', array2)
const newArr2 = countingSort2(array2, 21)
console.log('newArr2: ', newArr2)
// 原始 array:  [2, 2, 3, 8, 7, 1, 2, 2, 2, 7, 3, 9, 8, 2, 1, 4, 2, 4, 6, 9, 2]
// 计数排序耗时:   0.043212890625ms
// newArr:  	 [1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 4, 4, 6, 7, 7, 8, 8, 9, 9]

/**
 * name: 基数排序
 * @param  array 待排序数组
 * @param  max 最大位数
 */
const radixSort = (array, max) => {
	console.time('计数排序耗时')
	const buckets = []
	let unit = 10,
		base = 1
	for (let i = 0; i < max; i++, base *= 10, unit *= 10) {
		for (let j = 0; j < array.length; j++) {
			let index = ~~((array[j] % unit) / base) //依次过滤出个位，十位等等数字
			if (buckets[index] == null) {
				buckets[index] = [] //初始化桶
			}
			buckets[index].push(array[j]) //往不同桶里添加数据
		}
		let pos = 0,
			value
		for (let j = 0, length = buckets.length; j < length; j++) {
			if (buckets[j] != null) {
				while ((value = buckets[j].shift()) != null) {
					array[pos++] = value //将不同桶里数据挨个捞出来，为下一轮高位排序做准备，由于靠近桶底的元素排名靠前，因此从桶底先捞
				}
			}
		}
	}
	console.timeEnd('计数排序耗时')
	return array
}

const array = [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
console.log('原始array:', array)
const newArr = radixSort(array, 2)
console.log('newArr:', newArr)
// 原始 array:  [3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48]
// 堆排序耗时:   0.064208984375ms
// newArr:  	 [2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

// 桶排序
const bucketSort = (array, bucketSize) => {
	if (array.length === 0) {
		return array
	}

	console.time('桶排序耗时')
	let i = 0
	let minValue = array[0]
	let maxValue = array[0]
	for (i = 1; i < array.length; i++) {
		if (array[i] < minValue) {
			minValue = array[i] //输入数据的最小值
		} else if (array[i] > maxValue) {
			maxValue = array[i] //输入数据的最大值
		}
	}

	//桶的初始化
	const DEFAULT_BUCKET_SIZE = 5 //设置桶的默认数量为 5
	bucketSize = bucketSize || DEFAULT_BUCKET_SIZE
	const bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1
	const buckets = new Array(bucketCount)
	for (i = 0; i < buckets.length; i++) {
		buckets[i] = []
	}

	//利用映射函数将数据分配到各个桶中
	for (i = 0; i < array.length; i++) {
		buckets[Math.floor((array[i] - minValue) / bucketSize)].push(array[i])
	}

	array.length = 0
	for (i = 0; i < buckets.length; i++) {
		quickSort(buckets[i]) //对每个桶进行排序，这里使用了快速排序
		for (var j = 0; j < buckets[i].length; j++) {
			array.push(buckets[i][j])
		}
	}
	console.timeEnd('桶排序耗时')

	return array
}

// 快速排序
const quickSort = (arr, left, right) => {
	let len = arr.length,
		partitionIndex
	left = typeof left != 'number' ? 0 : left
	right = typeof right != 'number' ? len - 1 : right

	if (left < right) {
		partitionIndex = partition(arr, left, right)
		quickSort(arr, left, partitionIndex - 1)
		quickSort(arr, partitionIndex + 1, right)
	}
	return arr
}

const partition = (arr, left, right) => {
	//分区操作
	let pivot = left, //设定基准值（pivot）
		index = pivot + 1
	for (let i = index; i <= right; i++) {
		if (arr[i] < arr[pivot]) {
			swap(arr, i, index)
			index++
		}
	}
	swap(arr, pivot, index - 1)
	return index - 1
}

const swap = (arr, i, j) => {
	let temp = arr[i]
	arr[i] = arr[j]
	arr[j] = temp
}

const array = [4, 6, 8, 5, 9, 1, 2, 5, 3, 2]
console.log('原始array:', array)
const newArr = bucketSort(array)
console.log('newArr:', newArr)
// 原始 array:  [4, 6, 8, 5, 9, 1, 2, 5, 3, 2]
// 堆排序耗时:   0.133056640625ms
// newArr:  	 [1, 2, 2, 3, 4, 5, 5, 6, 8, 9]