算法排序 数组的常用方法 async/await

目录

一、数组拍平

二、数组排序

2.1 冒泡算法

2.2 选择排序

2.3 插入排序

2.4 希尔排序

2.5 归并排序

2.6 快速排序

三、异步顺序比较

3.1async await和promise先后顺序

四、数组方法

---

一、数组拍平

let array = [1, [2], [3, [4, [5,6]]]]
let flatArr = [];
function flat(arr){
    for( let i = 0; i < arr.length; i++ ){
        Array.isArray(arr[i])?flat(arr[i]):flatArr.push(arr[i]);
    }
    return flatArr
}
console.log(flat(array))

二、数组排序

2.1 冒泡算法

依次比较两个相邻的元素，如果他们的顺序错误就把他们交换过来

function bubbleSort(arr){
   let len = arr.length
   for(let i =0;i < len;i++){
        for(let j= 0;j < len-1-i;j++){
            if( arr[j] > arr[j+1]){
                [arr[j],arr[j+1]] = [arr[j+1],arr[j]];
            }  
        }
    }
    return arr;
}

2.2 选择排序

第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

function selectionSort(arr){
    let len = arr.length;
    for(let i =0;i < len;i++){
        let minIndex = i;
        for(let j= i;j < len;j++){
            if( arr[minIndex] > arr[j+1]){
                minIndex =  j+1;
            }  
        }
        [arr[minIndex],arr[i]] = [arr[i],arr[minIndex]]
    }
    return arr;
}

console.log(bubbleSort(arr1));

2.3 插入排序

,插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。

function insertionSort(arr){
            let len = arr.length    
            for(let i = 1;i < len;i++){
                let pre = i -1
                let current = arr[i]
                while(pre>=0&&arr[pre]>current){
                    arr[pre+1] = arr[pre]
                    pre--
                } 
                arr[pre+1] = current
            }
            return arr
        }

2.4 希尔排序

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

function shellSort(arr){
            let len = arr1.length,
                currentVal,
                gap = 1;
            while(gap < len /3){
                gap = gap * 3 + 1;
            }
            for( gap; gap>0; gap=Math.floor(gap/3)){
                for(let i = gap;i<arr1.length;i++){
                    currentVal= arr[i];
                    for(var j = i-gap;j>=0&&arr[j]>temp;j-=gap){
                        arr[j+gap] = arr[j];
                    }
                    arr[j+gap] = currentVal;
                }
            }
            return arr;
        }

2.5 归并排序

将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

function mergeSort(arr) {
    let len = arr.length;
    if (len < 2) {
        return arr
    }

    let middle = Math.floor(len / 2),
        left = arr.slice(0, middle),
        right = arr.slice(middle);
    return merge(mergeSort(left), mergeSort(right));
}
function merge(left, right) {
    let mergrArr = [];
    while (left.length && right.length) {
        if (left[0] <= right[0]) {
            mergrArr.push(left.shift());
        } else {
            mergrArr.push(right.shift());
        }
    }
    while (left.length) {
        mergrArr.push(left.shift());

    }

    while (right.length) {
        mergrArr.push(right.shift());
    }
    return mergrArr
}

2.6 快速排序（中间值，避免falg为最小值造成无限循环）

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

function quickSort(arr){
    let len = arr.length 
    if(len < 2){ 
        return arr
    }
    let randomkey =  Math.floor(len/2) 
    let randomVal = arr[randomkey]
    arr.splice(randomkey, 1)
    len--
    let leftArr = []
    let rightArr = []
    for(let i=0; i<len;  i++){
        if( arr[i] < randomVal ){
            leftArr.push(arr[i])
        }else {
            rightArr.push(arr[i])
        }
    }
    return quickSort(leftArr).concat(randomVal, quickSort(rightArr))
}

三、异步顺序比较

3.1async await和promise先后顺序

1. try/catch
        async function fn() {
            try {
                await new Promise((resolve, reject) => {
                setTimeout(() => {
                    reject('err3');
                }, 1000);

            })
            } catch (err){
                alert(err)

            }
        }
        fn()

2. catch

       async function fn() {
            await new Promise((resolve, reject) => {
                setTimeout(() => {
                    reject('err');
                }, 1000);
            })
        }
        fn().catch(alert)
      async function test1() {
            console.log('start test1');
            console.log(await test2());
            console.log('end test1');
        }
        async function test2() {
            console.log('test2');
            return 'return test2 value'
        }

        test1();
        console.log('start async');
        setTimeout(() => {
            console.log('setTimeout');
        }, 0);
        new Promise((resolve, reject) => {
            console.log('promise1');
            resolve();
        }).then(() => {
            console.log('promise2');
        });
        console.log('end async');

貌似关于异步的处理不同，谷歌await无需等待异步，火狐需要

谷歌：

火狐

、

四、数组方法

一、forEach
回调函数参数，item(数组元素)、index(序列)、arr(数组本身)
循环数组，无返回值，不改变原数组

二、includes
判断数组是否包含某个元素，不用return，不用回调函数，返回布尔值

let arr = ['你好','abc','123',1234]

console.log(arr.includes(123));//false

console.log(arr.includes('123'));//true

三、filter
使用return操作输出，会循环数组每一项，并在回调函数中操作
返回满足条件的元素组成的数组，不改变原数组

let arr = ['你好','abc','123',1234]

let arrfilter =  arr.filter(item=>{

            return item == 1234

        })

        console.log(arrfilter)//[1234]

四、map
输出的是return什么就输出什么新数组
原数组被“映射”成对应新数组，返回新数组，不改变原数组

let arr = ['你好','abc','123',1234]

let arrMap =  arr.map(item=>{

            return item += '1'

        })

        console.log(arrMap)// ["你好1", "abc1", "1231", "12341"]

五、find
用来查找目标元素，找到就返回该元素，找不到返回undefined
输出的是一旦判断为true则跳出循环输出符合条件的数组元素

let arr = ['你好','abc','123',1234, '123']

let arrFind =  arr.find(item=>{

            return item == '123'

        })

console.log(arrFind)//123

findIndex

let arrFindindex =  arr.findIndex(item=>{

            return item == '123'

        })

        console.log(arrFindindex)//2

六、some
返回布尔值，遇到满足条件变跳出循环

七、every
返回布尔值，遇到不满足条件跳出循环

八、reduce
累加器，输出的是return叠加什么就输出什么 index从1开始

        let arr = ['你好','abc','123',1234,'123']

let arrReduce =  arr.reduce((pre,cur,index,arr)=>{

            console.log(index);

            return pre + cur

        })

        console.log(arrReduce)

1

2

3

4

你好abc1231234123

1 arr.push() 从后面添加元素，返回值为添加完后的数组的长度

2 arr.pop() 从后面删除元素，只能是一个，返回值是删除的元素

3 arr.shift() 从前面删除元素，只能删除一个 返回值是删除的元素

4 arr.unshift() 从前面添加元素, 返回值是添加完后的数组的长度

5 arr.splice(i,n) 删除从i(索引值)开始的元素。返回值是删除的元素
6 arr.concat() 连接两个数组 返回值为连接后的新数组

7 str.split() 将字符串转化为数组

8 arr.sort() 将数组进行排序,返回值是排好的数组，默认是按照最左边的数字进行排序，不是按照数字大小排序的，见例子。

let arr1 = arr.sort((a, b) =>a - b) 

console.log(arr1)   // [1, 2, 3, 4, 6, 10, 22]

let arr2 = arr.sort((a, b) =>b-a) 

console.log(arr2)  // [22, 10, 6, 4, 3, 2, 1]

9 arr.reverse() 将数组反转,返回值是反转后的数组

17 arr.reduceRight(callback, initialValue) 与arr.reduce()功能一样，不同的是，reduceRight()从数组的末尾向前将数组中的数组项做累加。

18 arr.indexOf() 查找某个元素的索引值，若有重复的，则返回第一个查到的索引值若不存在，则返回 -1

19 arr.lastIndexOf()   和arr.indexOf()的功能一样，不同的是从后往前查找

20 Array.from() 将伪数组变成数组，就是只要有length的就可以转成数组。 ---es6

21 Array.of() 将一组值转换成数组，类似于声明数组    ---es6

29 arr.entries() 遍历数组的键名和键值

let arr = [1,2,3,4]

let arr1 = arr.entries()

for (let e of arr1) {

    console.log(e);   // [0,1] [1,2] [2,3] [3,4]

}

22 arr.copyWithin() 在当前数组内部，将制定位置的数组复制到其他位置，会覆盖原数组项，返回当前数组（会改变原数组）

　　参数: target --必选 索引从该位置开始替换数组项

　　　　  start --可选 索引从该位置开始读取数组项，默认为0.如果为负值，则从右往左读。

　　　　  end --可选 索引到该位置停止读取的数组项，默认是Array.length,如果是负值，表示倒数

let arr = [1,2,3,4,5,6,7]

let arr1 = arr.copyWithin(1)

console.log(arr1)   // [1, 1, 2, 3, 4, 5, 6]

let arr2 = arr.copyWithin(1,2)

console.log(arr2)   // [1, 3, 4, 5, 6, 7, 7]

let arr3 = arr.copyWithin(1,2,4)

console.log(arr3)   // [1, 3, 4, 4, 5, 6, 7]

25 arr.fill(target, start, end) 使用给定的值，填充一个数组,ps:填充完后会改变原数组

　　参数： target -- 待填充的元素

　　　　　 start -- 开始填充的位置-索引

　　　　    end -- 终止填充的位置-索引（不包括该位置)

let arr = [1,2,3,4,5]

let arr1 = arr.fill(5)

console.log(arr1)  // [5, 5, 5, 5, 5]

console.log(arr)   // [5, 5, 5, 5, 5]

let arr2 = arr.fill(5,2)

console.log(arr2)

let arr3 = arr.fill(5,1,3)

console.log(arr3)