基本时间复杂度为O(N^2)的排序算法

基本时间复杂度为O(N^2)的排序算法：

选择算法：从i位置开始记录最小值的下标target，遇到更小的，将target替换成它的下标，直到n-1，将target下标的值与0位置的值互换，则0到i位置有序。i++继续重复上述操作；

 /**选择排序 */
    sort(arr:number[],order:Function){
        let target = 0; 
        for(let i = 0; i< arr.length;i++){
            target = i;
            for(let j = i + 1;j<arr.length;j++){
                if(order(arr[j],arr[target])){
                    target = j;
                }
            }
            if(target != i){  //交换元素
                this.swap(arr,i,target);
            }
        }
        return arr;
    }

冒泡排序：从0位置开始，遇到右侧更小的数，互换位置，挨个检查，直到i，则i到n-1位置有序。i–继续重复上述操作。

    /**冒泡排序 */
    bubble(arr: number[], order: Function) {
        for (let i = arr.length - 1; i > 0; i--) {
            for (let j = 0; j <= i; j++) {
                if (order(arr[j + 1],arr[j])) {
                    this.swap(arr, j+1, j);
                }
            }
        }
        return arr;
    }

插入排序：从n-1位置往前，遇到左侧更大的数，互换位置，挨个检查，直到i，则0到i位置有序，i++继续重复上述操作。如果是往有序数组中加入元素并排序的情境，插入算法效率更高。

    /**插入排序 */
    insert(arr: number[], order: Function) {
        for (let i = 0; i < arr.length; i++) {
            for (let j = arr.length - 1; j >= i; j--) {
                if (order(arr[j], arr[j - 1])) {
                    this.swap(arr, j, j - 1)
                }
            }
        }
        return arr;
    }