冒泡排序

 window.onload = function() {

            var arr = [2,4,9,1,7,3,6,8,5]

            // 冒泡排序 
            bubbleSort(arr)
            // 优化后的冒泡排序
            bubbleSortNew(arr)
        }

        // 冒泡排序
        function bubbleSort(arr) {
            var list = [...arr]
            // 外层进行数组长度-1轮循环
            for (let i = 0; i < list.length - 1; i++) {
               console.log(`第${i}轮`)
               // 内层每轮进行数组长度-1-第几轮次循环比较
                for (let j = 0; j < list.length - 1 - i; j++) {
                    console.log(`第${j}次比较`)
                    if (list[j] > list[j + 1]) {
                        // 当前一个的值大于后一个的值进行交换
                        swap(list, j, j + 1)
                    }
                }
                
            }
            console.log(list) // [1, 2, 3, 4, 5, 6, 7, 8, 9]
        }

        // 优化后的冒泡排序
        function bubbleSortNew(arr) {
            console.log('~~~~~~~~~~~~~~~~~~')
            var list = [...arr]
            // 数组长度-1 记录内层循环的第一轮循环次数
            var num = arr.length - 1
            // 记录外层循环轮数(只用来打印日志)
            var m = 0
            while (true) {
                console.log(`第${m}轮`)
                m++
                // 记录最后一次交换时,数值所在的索引
                var last = 0
                for (let i = 0; i < num; i++) {
                    console.log(`第${i}次比较`)
                    if (list[i] > list[i+1]) {
                        swap(list, i, i + 1)
                        last = i
                    }
                    
                }
                // 将最后一次交换时数值所在的索引给到num,用于下次循环的次数
                num = last
                // 当num为0时说明已经结束,跳出外层循环
                if (num == 0 ) {
                    break
                }
            }
            console.log(list) // [1, 2, 3, 4, 5, 6, 7, 8, 9]

        }

        // 交换两个值
        function swap(arr, i, j) {
            var tmp = arr[i]
            arr[i] = arr[j]
            arr[j] = tmp
        }

对比以上两种方式发现，优化后的冒泡排序的循环次数比没优化的少进行了3轮外层循环；