js排序算法

js实现各种常见排序算法

冒泡算法

数组中元素按顺序前后两两比较，大的排后面

function bubbleSort(arr) {
	let len = arr.length
	for(let i = 0; i < arr.length - 1; i++) {
		for(let j = 0; j < arr.length - i - 1; j++) {
			if (arr[j] > arr[j + 1]) {
				let temp = arr [j + 1]
				arr[j + 1] = arr[j]
                arr[j] = temp
			}
		}
	}
	return arr
}

选择排序

从第一个元素开始，每个元素依次与之后的每一个元素进行比较，保存最小的数的序号，然后交换位置

function selectionSort(arr) {
	let minIndex, temp
	const len = arr.length
    for (let i = 0; i < len - 1; i++) {
		minIndex = i
		for (let j = i + 1 ; j < len; j++) {
			if (arr[j] < arr[minIndex]) {
				minIndex = j
			}
		}
        temp = arr[i]
        arr[i] = arr[minIndex]
		arr[minIndex] = temp
	}
	return arr
}

插入排序

从第二个元素开始，元素的值对比自身和自身之前的元素，如果小于则让之前的元素覆盖原来位置的值（大的值向后移），直到前面没有元素或者大于前面的元素，将值赋予之前的元素位置

function insertionSort(arr) {
	let len = arr.length
	let current, preI
    for(let i = 1; i < len; i++) {
		preI = i - 1
		current = arr[i]
		while(preI >= 0 && current < arr[preI]) {
            arr[preI + 1] =  arr[preI]
            preI--
			
		}
        arr[preI + 1] = current
	}
	return arr
}

快速排序

1. 数组中随机取一个元素作为基准数字
2. 小于基准数字的元素放左边，大于的放右边
3. 对左边子集和右边的子集循环进行以上操作，直到子集剩下一个元素

function quickSort(arr) {
    if(arr.length <= 1) return arr
	let si = Math.floor(arr.length/2)
    const left=[],right=[]
	const sv = arr.splice(si, 1)[0]
    for(let i = 0; i < arr.length; i++) {
    	if(arr[i] < sv) {
			left.push(arr[i])
		} else {
            right.push(arr[i])
		}
	}
    return quickSort(left).concat([sv], quickSort(right));
}

希尔排序

希尔排序关键在于增量的设置,根据增量分割数组并逐步进行直接插入排序,增量逐趟减少,并最后使得整个数组基本有序,再对整体进行直接插入排序.

function shellSort() {
    let len =arr.length
    gap = Math.floor(len / 2)
    while(gap !== 0) {
        for(let i = gap; i < len; i++){
            let temp = arr[i]
            let j;
            for(j=i - gap; j >= 0 && temp < arr[j]; j -= gap){
                arr[j + gap] = arr[j];
            }
            arr[j + gap] = temp;
        }
        gap = Math.floor(gap / 2);
    }
    return arr;
}