算法-基础篇(选择排序，插入排序，冒泡排序)

• 选择排序
• 插入排序
• 冒泡排序

具体代码，在html中分别引入以下文件：
sortHelpder.js

window.sortHelper = {
    // 数组值互换
    exchange(arr,i,j) {
        let tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    },
    // 生成一个指定范围内的随机数
    generateRandom({min,max}) {
        return parseInt(Math.random()*(max-min+1)+min,10);
    },
    // 生成一个指定范围内数组
    generateRandomArray({len, min, max}) {
        let arr = [];
        for (let i=0; ireturn arr;
    },
    // 生成一个接近有序但不是有序的数组
    generateNearlyOrderedArray({len, swapTimes}) {
        let arr = [];
        for (let i=0; ifor (let i=0; ilet x = sortHelper.generateRandom({min:0,max:len-1});
            let y = sortHelper.generateRandom({min:0,max:len-1});
            sortHelper.exchange(arr,x,y);
        }
        return arr;
    },
    // 检查是否进行了 升序 排序
    isSorted({arr}) {
        for (let i=0,j=1,len=arr.length; jif (arr[i]>arr[j]) {
                return false;
            }
        }
        return true;
    },
    // 性能测试
    testSort({arr,fn}) {
        let t1 = new Date().getTime();
        arr = fn({arr});
        let t2 = new Date().getTime();
        let s = (t2-t1)/1000;
        console.log(`是否升序：` + sortHelper.isSorted({arr}));
        console.log(fn.name + "：" + s + " s");
    },
}

sortBasic.js

window.sortBasic = {
    // 选择排序，默认是升序
    select({arr,orderby = "asc"}) {
        for (let i=0; ilet minIndex = i;
            for (let j=i+1; jif (arr[minIndex]>arr[j]) {
                    minIndex = j;
                }
            }
            sortHelper.exchange(arr,i,minIndex);
        }
        return orderby=='asc' ? arr : arr.reverse;
    },
    // 插入排序
    insert({arr,orderby="asc"}) {
        // 基本的，性能需要优化
        // for (let i=1,len=arr.length; i
        //     for (let j=i; j>0 && arr[j]
        //         sortHelper.exchange(arr,j,j-1);
        //     }
        // }
        for (let i=1,len=arr.length; ilet num = arr[i], j;
            for (j=i; j>0 && arr[j-1]>num; j--) {
                arr[j] = arr[j-1];
            }
            arr[j] = num;
        }
        return orderby=='asc' ? arr : arr.reverse;
    },
    insert_limit({arr,l,r}) {
        for (var i=l+1; i<=r; i++) {
            var e = arr[i], j;
            for (j=i; j>l && arr[j-1]>e; j--) {
                arr[j] = arr[j-1];
            }
            arr[j] = e;
        }
    },
    // 冒泡排序
    bubble({arr,orderby="asc"}) {
        let toggleSwap = false,
            len = arr.length;
        do {
            toggleSwap = false;
            for (let i=1; iif (arr[i-1]>arr[i]) {
                    sortHelper.exchange(arr,i-1,i);
                    toggleSwap = true;
                }
            }
            len--;
        } while (toggleSwap)
        return orderby=='asc' ? arr : arr.reverse;
    },
}

test.js，用于测试效率：

//  测试1
let {
    generateRandomArray,
    testSort,
    generateNearlyOrderedArray,
} = sortHelper,
{
    select,
    insert,
    bubble,
} = sortBasic,
    arr1 = generateRandomArray({len:100000,min:1,max:1000}),
    arr2 = JSON.parse(JSON.stringify(arr1));
    arr3 = generateNearlyOrderedArray({len:100000,swapTimes: 10}),
    arr4 = JSON.parse(JSON.stringify(arr3));

//test1 选择排序vs插入排序，插入排序good
// testSort({arr:arr1, fn:select});
// testSort({arr:arr2, fn:insert});

// test2 插入排序vs冒泡排序：插入排序good
// testSort({arr:arr1, fn:insert});
// testSort({arr:arr2, fn:bubble});

// test3 插入排序vs冒泡排序，但是数据源是接近有序的：插入排序best，用时非常少
// testSort({arr:arr3, fn:insert});
// testSort({arr:arr4, fn:bubble});

插入排序的逻辑：