华为机试一面----（代码题） + 排序总结

• 题1 ： 给定一系列数，和一个sum和，求序列中最大子序列的长度为多少？？ 使用简单动态规划即可。
• 代码

 function findMax(arr, sum) {
            let memo = [];
            memo[0] = arr[0];

            let res = [];
            res.push(arr[0]);
            let max = -1;

            for (let i = 1; i < arr.length; i++) {
                memo[i] = Math.max(arr[i] + memo[i - 1], arr[i]);
                if (memo[i] < sum) {
                    res.push(arr[i]);
                } else if (memo[i] === sum) {
                    res.push(arr[i]);
                    max = Math.max(max, res.length);
                    memo[i + 1] = arr[i + 1];
                } else {
                    memo[i + 1] = arr[i + 1];
                }
            }
            return max;
        }
        let arr = [1, 2, 3, 4, 3, 2];
        let sum = 6;
        console.log(findMax(arr, sum));

• 题2 ： 给定一系列中，求组合成的最大值 – 使用选择排序
• 代码

        // 法1: 利用数组的sort函数
        function maxValue2(str) {
            let aa = str.split('').sort((a, b) => b - a);
            let res = aa.reduce((acc, cur) => acc + cur, '');
            return res;
        }
        
        // 法2：利用简单选择排序
        function maxValue(str) {
            let arr = str.split(" ");
            // 选择排序
            for (let i = 0; i < arr.length - 1; i++) {
                for (let j = i + 1; j < arr.length; j++) {
                    if (parseInt(arr[i] + arr[j]) < parseInt(arr[j] + arr[i])) {
                        let temp = arr[j];
                        arr[j] = arr[i];
                        arr[i] = temp;
                    }
                }
            }
            let res = arr.reduce((total, val) => total + val, "")
            return res;
        }

        let str = "10 9";
        console.log(maxValue2(str))

复习：排序算法（简单选择）

        // 1. 简单选择排序：一次选择一个放在最终的位置
        let array = [1, 2, 11, 45, 23]

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

        console.log(selectSort(array));

• sort()

        let a1 = ['ba', 'abble', 'aco', 'cat'];
        console.log(a1.sort()); //sort 对字符串实现字典排序

        let a2 = [23, 133, 2, 35, 244];
        console.log(a2.sort()); // 按照首字母进行排序
        console.log(a2.sort((a, b) => a - b)); //递增
        console.log(a2.sort((a, b) => b - a)); // 递减

• 快速排序 （递归）

  		//1. 传统快速排序思想
        function quickSort(arr, left, right) {
            let len = arr.length,
                i = left === undefined ? 0 : left,
                j = right === undefined ? len - 1 : right;

            if (i < j) {
                partitionIndex = partition(arr, i, j); // 找到中间值下标
                quickSort(arr, i, partitionIndex - 1);
                quickSort(arr, partitionIndex + 1, j)
            }
            return arr;
        }

        function partition(arr, left, right) {
            let pivot = left,
                index = pivot + 1; // 从pivot后面的第一个索引开始遍历
            for (let i = index; i <= right; i++) {
                if (arr[i] < arr[pivot]) {
                    swap(arr, i, index);
                    index++;
                }
            }
            swap(arr, pivot, index - 1); // 交换pivot的最终位置，为index - 1
            return index - 1;
        }


        function swap(arr, i, j) {
            var temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }

        let arr = [45, 112, 23, 38]

        console.log(quickSort(arr));


        // 2. 使用数组实现

        function quickSort2(arr, left, right) {
            if(arr.length < 1) return arr;
            
            let i = left == undefined ? 0 : left,
                j = right == undefined ? arr.length - 1 : right;

            let pivotIndex = Math.floor(arr.length / 2);
            let pivot = arr.splice(pivotIndex, 1)[0]; // 把中间值从原来数组中删除

            let l = [],
                r = [];

            for (let i = 0; i < arr.length; i++) {
                if(arr[i] < pivot) {
                    l.push(arr[i]);
                } else {
                    r.push(arr[i]);
                }

            }

            return quickSort2(l).concat([pivot], quickSort2(r));

        }
        console.log(quickSort2(arr))