javascript经典算法

冒泡排序:

// 冒泡排序
let arr = [8, 6, 7, 15, 88, 66, 77, 99, 12, 45, 789, 48, 216, 466546, 45] //设置原始数组
console.log(arr) //打印原始数组
for (let i = arr.length - 1; i > 0; i--) {
    /*需要循环多少次【交换组】，交换组的意思是从0开始到一次交换结束，比如9，8，4，
        需要两次交换组才能完成最终排序，第一次交换组得出的排序是8，4，9，第二次是4，8，9，
        自己瞎定义的一个概念
        */
    for (let j = 0; j < i; j++) { //代表一次交换组
        if (arr[j] > arr[j + 1]) { //判断交换
            arr[j] = arr[j] ^ arr[j + 1];
            arr[j + 1] = arr[j] ^ arr[j + 1];
            arr[j] = arr[j] ^ arr[j + 1];
        }
    }
}
console.log(arr) //打印排序数组

堆排序

//堆排序
//交换数值的函数
let exchange = function(arr, a, b) {
    if (a != b) { //当a==b时则不进行交换
        arr[a] = arr[a] ^ arr[b] 
        arr[b] = arr[a] ^ arr[b] 
        arr[a] = arr[a] ^ arr[b]
    }
}

//arr是数组
//fatherNumber是父节点的下标
//length为数组长度
//建堆方法
let build = function(arr, fatherNumber, length) {
    if (fatherNumber < length) { //排除只有0个数字的数组
        let max = fatherNumber //最大数的下标
        let left = fatherNumber * 2 + 1 
        let right = fatherNumber * 2 + 2
        if (left < length) {
            if (arr[left] > arr[max]) {
                max = left
            }
        }
        if (right < length) {
            if (arr[right] > arr[max]) {
                max = right
            }
        }
        if (arr[max] != arr[fatherNumber]) { //如果max已经赋值给right或者left，则执行if
            exchange(arr, max, fatherNumber) //交换父亲节点和最大数节点（可能是子左节点或者右子节点）
            build(arr, max, length) //以子节点的下标为准(标注了max的子节点)继续向下建堆
            //，执行递归函数
        }
    }
}

//单次堆排序
let heapSort = function(arr, length) {
    for (let i = length - 1; i >= 0; i--) { //由下而上的建堆，保证根节点为最大的数值
        build(arr, i, length)
    }
}

// 多次堆排序
let dpx = function(arr, length) {
    for (let k = 0; k < length; k++) { //需要循环的次数
        heapSort(arr, length - k) //忽视已经排好了的数值，所以才length
        exchange(arr, 0, length - k - 1) //交换根节点和下标为length-k-1的节点
    }
}

//执行
let app = [44, 88, 9, 7, 987, 10, 45, 87, 98, 50] 
console.log(app) 
dpx(app, app.length) 
console.log(app)