前端算法之 冒泡排序 快排

冒泡排序

        const arr = [1, 3, 4, 5, 7, 6, 2, 76, 0, 223];
        const len = arr.length;
        let tem;
        for (let i = 0; i < len; i++) {
            for (let j = 0; j < len - i - 1; j++) {
                if (arr[j] < arr[j + 1]) {
                    tem = arr[j]
                    arr[j] = arr[j + 1]
                    arr[j + 1] = tem
                }
            }
        }
        console.log(arr);

封装之后的冒泡排序

        const arr = [1, 3, 4, 5, 7, 6, 2, 76, 0, 223];
        function sort(arr) {
            const len = arr.length;
            let tem;
            for (let i = 0; i < len; i++) {
                for (let j = 0; j < len - i - 1; j++) {
                    if (arr[j] < arr[j + 1]) {
                        tem = arr[j]
                        arr[j] = arr[j + 1]
                        arr[j + 1] = tem
                    }
                }
            }
            return arr
        }
        console.log(sort(arr));

使用快排同样能实现排序

       let arr = [];

        for (let i = 0; i < 100; i++) {
            const num = parseInt(Math.random() * 100 + 1);
            arr.push(num)
        }

        function quicksort(arr) {
            if (arr.length < 2) {
                return arr
            } else {
                const index = Math.floor(arr.length / 2)
                const center = arr[index];
                arr.splice(index, 1)
                let left = [],
                    right = [];
                for (let i = 0; i < arr.length; i++) {
                    if (arr[i] < center) {
                        left.push(arr[i])
                    } else {
                        right.push(arr[i])
                    }
                }
                return quicksort(left).concat([center], quicksort(right))
            }
        }

        console.log(quicksort(arr))

快排会用到递归, 递归需要有退出条件, 不然会照成 栈溢出

还有一点是递归有很大的性能问题, js本身不适合做算法, 所以慎用

只是递归相当于上面的冒泡排序,性能上还要好一点, 所以两样同时拿出来说