javascript中的算法相关

   <script>
        // javascript中的算法问题
        // 1.冒泡排序
        const arrList = [8, 30, 6, 48, 99, 66]

        function sortArr(arr) {
            for (let i = 0; i < arr.length - 1; i++) {
                for (let j = 0; j < arr.length - 1 - i; j++) {
                    if (arr[j] > arr[j + 1]) {
                        var temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
            return arr
        }
        sortArr(arrList)

        console.log(arrList)

        // sort方法排序
        const arrList1 = [8, 30, 6, 48, 99, 66]
        console.log(arrList1.sort((a, b) => {
                return b - a
            }))
            // 2.快速排序
        const arrList2 = [8, 30, 6, 48, 99, 66]

        function quickSort(arr) {
            if (arr.length <= 1) {
                return arr;
            }
            let left = []
            let right = []
            let current = arr.splice(0, 1);
            for (let i = 0; i < arr.length; i++) {
                if (arr[i] < current) {
                    left.push(arr[i])
                } else {
                    right.push(arr[i])
                }
            }
            return quickSort(left).concat(current, quickSort(right))
        }
        console.log('快速排序后', quickSort(arrList2))

        //3.二路归并 将两个按值有序序列合并成一个按值有序序列，则称之为二路归并排序
        function marge(left, right) {
            var result = [];
            il = 0;
            ir = 0;
            while (il < left.length && ir < right.length) {
                if (left[il] < right[ir]) {
                    result.push(left[il++]);
                } else {
                    result.push(right[ir++]);
                }
            }
            while (left[il]) {
                result.push(left[il++]);
            }
            while (right[ir]) {
                result.push(right[ir++]);
            }
            return result;
        }

        const leftList = [1, 69, 8, 5, 65, 64, 54, 'name']
        const rightList = [1, 69, 8, 65, 65, 'name', 89, 6, 56, 6]
        console.log('二路归并', marge(leftList, rightList))

        // 4.统计出现次数最多的字符串中的字母
        const str = 'aasdfsdfsdsdfsdfsfsfsfffgfgfgfgghfh'
        const o = {}
        for (var i = 0; i < str.length; i++) {
            var char = str.charAt(i);
            // console.log('char', char)
            if (o[char]) {
                // console.log('这是', o[char])
                o[char]++; //次数加1
            } else {
                o[char] = 1; //若第一次出现，次数记为1
            }
            // console.log('o', o);
            //输出的是完整的对象，记录着每一个字符及其出现的次数

            //遍历对象，找到出现次数最多的字符的次数
            var max = 0;
            for (var key in o) {
                if (max < o[key]) {
                    max = o[key]; //max始终储存次数最大的那个
                }
            }
            for (var key in o) {
                if (o[key] == max) {
                    //console.log(key);
                    // console.log("最多的字符是" + key);
                    // console.log("出现的次数是" + max);
                }
            }
        }
        //5 数组去重
        //利用Object中的key的唯一性，利用key来进行筛选
        function unique(arr) {
            var obj = {}
            var data = []
            for (var i in arr) {
                if (!obj[arr[i]]) {
                    obj[arr[i]] = true;
                    data.push(arr[i]);
                }
            }
            console.log(data)
            return data;
        }
        unique(arrList1)

        //6 数组查重
        const arrList3 = [1, 5, 89, 65, 87, 45, 'name', 'same', 'name']

        var ret = function(arr) {
            var res = [arr[0]];
            var ch = [];
            for (var j = 1; j < arr.length; j++) {
                var repeat = false;
                for (var i = 0; i < res.length; i++) {
                    if (arr[j] == res[i]) {
                        //alert("重复的元素为："+arr[j])
                        ch.push(arr[j]);
                        repeat = true;
                        break;
                    }
                }
                if (!repeat) {
                    res.push(arr[j]);
                }
            }
            return ch;
        }
        console.log(ret(arrList3))
            // 7NUMber数组中最大差值
        function getMaxProfit(arr) {
            var min = arr[0],
                max = arr[0];
            for (var i = 0; i < arr.length; i++) {
                if (arr[i] < min)
                    min = arr[i];
                if (arr[i] > max)
                    max = arr[i];
            }
            return max - min;
        }
        console.log('数组中的最大差值', getMaxProfit(arrList1))

        //8 阶乘
        //8.1非递归实现
        //1. 非递归实现 阶乘6 1*2*3*4*5*6
        function factorialize(num) {
            var result = 1;
            if (num < 0) return -1;
            if (num == 0 || num == 1) return 1;
            while (num > 1)
                result *= num--;
            return result;
        }
        console.log('阶乘', factorialize(6))
            //2 递归实现
            //2. 递归实现
        function factorialize2(num) {
            var result = 1;
            if (num < 0) return -1;
            if (num == 0 || num == 1) return 1;
            if (num > 1) {
                return num * factorialize(num - 1);
            }
        }
        console.log('递归阶乘', factorialize2(5))
            //5.生成斐波那契数列
            // 斐波拉契：又称黄金分割数列，值得是一个数列：0、1、2、3、5、8、13、21、34…，在数学上，斐波拉契数列主要考察递归的调用。
            //强行递归实现
        function getfib(n) {
            if (n == 0)
                return 0;
            if (n == 1)
                return 1;
            if (n > 1) {
                return getfib(n - 1) + getfib(n - 2);
            }
        }

        function fibo(len) {
            var fibo = [];
            for (var i = 0; i < len; i++)
                fibo.push(getfib(i));
            return fibo;
        }

        //方法2.非递归实现

        function getFibonacci(n) {
            var fibarr = [];
            var i = 0;
            while (i < n) {
                if (i <= 1) {
                    fibarr.push(i);
                } else {
                    fibarr.push(fibarr[i - 1] + fibarr[i - 2])
                }
                i++;
            }
            return fibarr;
        }
        // 6.二分查找
        // 非递归实现
        const arrList4 = [1, 2, 3, 4, 5, 6, 'name']

        function binary_search(arr, key) {
            var low = 0,
                high = arr.length - 1;
            while (low <= high) {
                var mid = parseInt((high + low) / 2);
                if (key == arr[mid]) {
                    return mid;
                } else if (key > arr[mid]) {
                    low = mid + 1;
                } else if (key < arr[mid]) {
                    high = mid - 1;
                }
            }
            return -1;
        };
        console.log('二分查找', binary_search(arrList4, 4))

        //递归实现
        function binary_search2(arr, low, high, key) {
            if (low > high)
                return -1;
            var mid = parseInt((low + high) / 2);
            if (key == arr[mid])
                return mid;
            else if (key > arr[mid])
                return binary_search2(arr, mid + 1, high, key);
            else if (key < arr[mid])
                return binary_search2(arr, low, mid - 1, key);
        }
    </script>