数组排序方法

内置排序

let arr =[1,2,99,13,4,99,6,4,7]
arr.sort((a,b)=>{
//返回值如果是正值,大于零 两个数就进行交换,负值不交换,相等也不交换
    return a-b
})
//此时的arr就是排序好了的数组

冒泡排序

let arr =[1,2,98,13,4,99,6,4,7]
//借助中间变量temp存储
// let temp //ES6之前需要使用中间变量
for(let i=0;i<arr.length;i++){
    for(let j=i+1;j<arr.length;j++){
        // 循环比较
        if(arr[i]>arr[j]){
           [arr[i],arr[j]] = [arr[j],arr[i]] //ES6 写法
           /* ES6 之前的写法
           temp = arr[i] 
           arr[i] = arr[j]
           arr[j] = temp
           */
        }
    }
}
// 此时arr就是从小到大排序好的数组

python的冒泡思想有很多写法，个人认为较容易理解的是和js类似的

def bubbleSort(arr):
    # for i in range(len(arr)):也可以只不过多比较一次
    for i in range(len(arr)-1):
        for j in range(i+1,len(arr)):
            if arr[i]>arr[j]:
                arr[j],arr[i] = arr[i],arr[j]
            print(arr)

选择排序

// 选择排序每次选择最小的放到无序区的最左边
function selectSort(arr) {
    //  let temp = null //ES6之前的写法需要使用中间变量在后面使用
    for (let i = 0; i < arr.length; i++){
        // 上来可以假设无序区最小的就是最左边的
        let min = i
        // 如果无序区有比最小的小的值就代表第j个是最小的也就是拿到最小值的下标
        for (let j = i+1; j < arr.length; j++) {
            if(arr[j]<arr[min]){
                min = j
            }
        }
        // 将最小的和无序区最左边的值交换因此
        [arr[min],arr[i]] = [arr[i],arr[min]]
        /*
        temp= arr[i]
        arr[i] = arr[min];
        arr[min] = temp
        */
    }
}
let arr = [1, 3, 5, 2, 2, 1, 9, 7];
console.log(arr);
selectSort(arr);
console.log(arr);

插入排序

// 类似于摸牌
function insertSort(arr) {
    // 其中i相当于摸到的牌
    for (let i = 1; i < arr.length; i++) {
        // j相当于手中的牌的最后一张
        let j = i - 1;
        // 当摸到的牌小于手中的牌时将手中的牌向后移动一个直到手中的牌小于摸到的牌
        while (j >= 0 && arr[j] >= arr[j+1]) {
            [arr[j+1],arr[j]] = [arr[j],arr[j+1]] //ES6写法数组解构不需要使用中间变量
            j -= 1
        }
    }
}
let arr = [1, 3, 5, 2, 2, 1, 9, 7];
console.log(arr);
insertSort(arr);
console.log(arr);

快速排序
代码相对来说理解起来相对复杂

function partition(arr, left, right) {
    // 任意找一个数先存起来
    let temp = arr[left];
    // 当左侧的指针小于右侧时候就进行循环，如果等于就证明arr[left] === arr[right] 直接赋值
    while (left < right) {
        // 从右侧开始找一个比temp小的数找到后就交换位置到左侧
        while (left < right && arr[right] >= temp) {
            // 如果右侧一直找不到比temp小的数就让右侧指针向左移动
            right -= 1
        }
        // 找到后交换位置
        arr[left] = arr[right]
            // 从左侧开始找一个比temp大的数找到后就交换位置到右侧
        while (left < right && arr[left] <= temp) {
            // 如果左侧一直找不到比temp大的数就让左侧指针向右移动
            left += 1
        }
        // 找到后交换位置
        arr[right] = arr[left]
    }
    arr[left] = temp
        // 最后返回中间位置。left就是right返回哪个都无所谓
    return left
        // return right
}

function quickSort(arr, left, right) {
    // 如果传过来的参数left<right则证明至少两个参数，如果一个参数那必定有序，如果不判断那么就会死循环递归
    if (left < right) {
        let mid = partition(arr, left, right)
            //对已经归位的元素的左侧进行排序
        quickSort(arr, left, mid - 1)
            //对已经归位的元素的右侧侧进行排序
        quickSort(arr, mid + 1, right)
    }

}
let arr = [6, 3, 5, 2, 2, 1, 9, 7];
quickSort(arr, 0, arr.length - 1)
console.log(arr);

希尔排序和插入排序极为类似，只不过是在插入排序的基础上修改的,可以借鉴B站链接:https://www.bilibili.com/video/BV1RT4y1K7ww?p=34

//将插入排序中的1全部替换成gap参数
function insertSortGap(arr,gap) {
    // 其中i相当于摸到的牌
    for (let i = gap; i < arr.length; i++) {
        // j相当于手中的牌的最后一张
        let j = i - gap;
        // 当摸到的牌小于手中的牌时将手中的牌向后移动一个直到手中的牌小于摸到的牌
        while (j >= 0 && arr[j] >= arr[j+gap]) {
            [arr[j+gap],arr[j]] = [arr[j],arr[j+gap]] //ES6写法数组解构不需要使用中间变量
            j -= gap
        }
    }
}

function shellSort(arr){
	let d = Math.floor(arr.length / 2);
	while(d >= 1){
		insertSortGap(arr,d);
		d = Math.floor(d / 2);
	}
}


let arr = [1, 3, 5, 2, 2, 1, 9, 7];
console.log(arr);
shellSort(arr);
console.log(arr);