关于数组的一些干货笔试题

最近从上一家公司离职以后面试比较多, 然后关于数组这块接触了一些比较具有代表性的问题, 此贴会长期进行更新, 面试的小伙伴可以看看

1. 字符串反转 ‘123abc’ --> ‘abc123’

  function reverseStr(str) {
            var arr = str.split('');
            str = arr.reverse().join('');
            return str;
        }

   console.log(reverseStr('123abc'));

2. 在有序的数组中找出指定的值, 返回该值在数组中的索引(二分查找)

    function findIndex(arr, val) {
        // 严谨性判断
        if(!arr || !(arr instanceof Array)) {
            return;
        }
        // 设定要查找的开始索引和结束索引
        var first = 0;
        var last = arr.length - 1;       
        function caculate(arr, first, last) {
            // 设定一个中间值mid索引
            var mid = Math.floor((first + last) / 2);
            if(last < first) {
                return -1;
            }
            if(arr[mid] === val) {  // 如果这个中间值刚好是val 那就直接返回mid索引
                return mid;
            }else if(arr[mid] > val) {  // 如果大于的话那就证明val在mid索引的左边所以我们要更改一下last索引继续查找
                last = mid - 1;
                return caculate(arr, first, last);
            }else if(arr[mid] < val) { // 如果小于的话就证明val在mid索引的右边
                first = mid + 1;
                return caculate(arr, first, last);
            }
        }
        return caculate(arr, first, last);    
    }

    var arr = [1, 3, 4, 6, 8, 9];

    console.log(findIndex(arr, 16));

3. 判断数组是否为对称数组, 对称数组形式如: [a, b, c, b, a] [a, b, c, c, b, a]

function symmetric(arr) {
        // 严谨性判断
        if(!arr || !(arr instanceof Array)) {
            return;
        }

        var first = 0;
        var last = arr.length - 1;

        for(var i = 0; i < arr.length; i ++) {
            if(first > last) {
                return true;
            }
            // 我们把倒数第一位和第一位比, 倒数第二位和第二位比 一个累加一个累减
            if( arr[first ++] !== arr[last --]) {
                return false
            }
        }
        return true;
    } 


    var arr1 = ['a', 'b', 'c', 'c', 'b', 'a'];
    var arr2 = [1, 2, 1];
    var arr3 = ['a','c','d'];

    console.log(symmetric(arr3));

4. 查询子串首次出现的位置, 如: 在accbca查找ca 返回4

 var parentArr = ['x', 'y', 'z', 'a', 'b', 'x'];
        var sonArr = ['z', 'a'];

        function myIndexOf(origin, sub) {
            // 严谨性判断
            if(!origin || !sub || origin.length === 0 || sub.length === 0) {
                return;
            }

            // 要小于origin.length - sub.length  因为如果最后的字符串长度比sub的长度小的话那真的没有比较的必要
            for(var i = 0; i < origin.length - sub.length; i++) {
                for(var j = 0; j < sub.length; j++) {
                    if(sub[j] !== origin[i + j]) {
                        break; // 跳出本次内层循环
                    }
                    // 如果j 都走到sub.length - 1 了还没有被break掉的话那证明这个字符串匹配上了
                    if(j === sub.length - 1) {
                        return i;
                    }
                }
            }
            return -1;
        }


        console.log(myIndexOf(parentArr, sonArr));

5. 计算数组中, 最大连续增长子序列的长度, 如[1, 2, 3, 4, 1, 2, 3, 4, 5, 1, 2]返回5

  var continueArr = [1, 2, 3, 4, 2, 3, 4, 6, 7, 1];

        function caculateContinue(arr) {
            // 严谨性判断 
            if(!arr || arr.length === 0) {
                return 0;
            }
            var finaNum = null; // 最后存放长度的变量
            var finaIndex = 0; // 存放每一次断开以后的索引
            for(var i = finaIndex; i < arr.length; i++) {
                if(arr[i + 1] < arr[i]) {
                    finaIndex = i + 1;
                    finaNum = i + 1 - finaNum;
                }
            }

            return finaNum;
        }

        console.log(caculateContinue(continueArr));