冒泡算法，对数组内的所有正数进行排序，非正数的位置不变，要求每次交换后暂停1s

题目要求：

// 写出冒泡算法， 对数组内的所有正数进行排序，（ 非正数的位置不变）， 要求每次交换后暂停1s 代码如何写

// 如：[11, -1, 6, 5, -4, -7, 9, 8] 结果：[5， - 1， 6， 8， - 4 - 7， 9， 11]

 

思路：

1. 先筛选出正数，同时把每一个正数都通过一个对象（map）保存它在原数组中的位置

2. 对只包含正数的新数组，进行一次冒泡排序。然后根据map对象保存的映射关系，找到原数组中应该交换的两个元素的下标

3. 根据找到的两个下标，交换原数组要交换的元素。然后更新map对象中的映射关系（因为要映射的元素的位置发生了变化）

4. 通过异步对象实现每次交换后暂停一秒

js代码：

 

let arr = [11, -1, 6, 5, -4, -7, 9, 8]

let sleep = (sleepTime) => {
    // 相对于用while轮询时间戳的方式，异步对象在资源占用方面好很多
    return new Promise((resolve, reject) => {
        setTimeout(resolve, sleepTime)
    })
}

let bubbleSort = async (a) => {
    let map = {}
    let arr = a.filter((item, index) => {
        if (item > 0) {
            // 例如 把新数组中的11映射到原数组中的下标0，map对象中的键值对是 '11': 0
            map[item] = index
            return item
        }
    })
    let len = arr.length,
        cnt = 0
    for (let i = 0; i < len - 1; i++) {
        for (let j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                let temp = arr[j]
                arr[j] = arr[j + 1]
                arr[j + 1] = temp
                // 交换的位置是j和j+1
                a[map[arr[j + 1]]] = arr[j]
                a[map[arr[j]]] = arr[j + 1]
                // 交换位置后，更新map中的映射关系
                temp = map[arr[j]]
                map[arr[j]] = map[arr[j + 1]]
                map[arr[j + 1]] = temp
                console.log(`第${++cnt}次排序: 【新数组：${arr}】，
　　　　　　　　　　　　　　【原数组：${a}】，【交换的元素：${arr[j]} ${arr[j+1]}】，
　　　　　　　　　　　　　　【原数组交换的下标：${map[arr[j]]} ${map[arr[j + 1]]}】`);
                await sleep(1000)
            }
        }
    }
}

bubbleSort(arr)