JS解剑指offer算法题 其中10题

*1.（二维数组查找）*在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

首先判断target是否在数组范围内；
接下去因为左上——>右下是升序的，比较array[i][col-1]与target的大小关系，一排一排的排除，减小时间复杂度。

var findNumberIn2DArray = function(matrix, target) {
    var row=matrix.length;
    if(row===0||matrix[0][0]>target||matrix[row-1][col-1]<target){
        return false;
    } 
    var col=matrix[0].length;   //此语句不能放在前面，若输入为[]，则不存在matrix[0].length
    for(let i=0;i<row;i++){
        if(matrix[i][col-1]<target){
            continue;
        }
        if(matrix[i].indexOf(target) != -1){
            return true;
        }
    }
    return false;
};

*2.（字符替换）*请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

通过replace()函数实现。

function replaceSpace(str)
{
    // write code here
    var str1=str.replace(/ /g,'%20');
    return str1;
}

*3.（指针链表）*输入一个链表，按链表从尾到头的顺序返回一个ArrayList。

js的变量定义很简单；倒序使用reverse()函数。

function printListFromTailToHead(head)
{
    // write code here
    var arr=[];
    var p=head;
    while(p){
        arr.push(p.val);
        p=p.next;
    }
    return arr.reverse();
}

*4.（二叉树）*输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

首先设置一个节点，建树过程使用递归。

var buildTree = function(preorder, inorder) {
    if(preorder.length===0 || inorder.length===0){
        return null;
    }
    var gen=inorder.indexOf(preorder[0]);
    var node=new TreeNode(preorder[0]);
    node.left=buildTree(preorder.slice(1,gen+1),inorder.slice(0,gen));
    node.right=buildTree(preorder.slice(gen+1),inorder.slice(gen+1));
    return node;
};

5.（栈）用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

var CQueue = function() {
    this.array1=[];
    this.array2=[];
};
/** * @param {number} value
 * @return {void}*/
CQueue.prototype.appendTail = function(value) {
    this.array1.push(value);
};

/*** @return {number} */
CQueue.prototype.deleteHead = function() {

    if(this.array2.length===0){
        while(this.array1.length){
            this.array2.push(this.array1.pop())
        }
        return this.array2.pop() || -1;
    }
    return this.array2.pop()
};

6.（数组找最小值）把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

function minNumberInRotateArray(rotateArray)
{
    // write code here
    if(rotateArray.length===0)
        return 0
    var x=rotateArray[0]
    for(var i=1;i<rotateArray.length;i++){
        if(x>rotateArray[i])
            break
        else x=rotateArray[i]
    }
    return rotateArray[i]
}

7.（循环累加/递归）大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。
n<=39

//for循环
var fib = function(n) {  
    // write code here
    let f=[BigInt(0),BigInt(1)];  //需要考虑溢出问题！！
    if(n<2){
        return f[n];
    }else{
        for(let i=2;i<=n;i++){
            let x=f[i-1]+f[i-2];
            f.push(x);
        }
        return f[n] % BigInt(1000000007);
    }
};
//递归方式
int Fibonacci(int n) {
        if(n==0)
            return 0;
        else if(n==1||n==2)
            return 1;
        else if(n==3)
            return 2;
        else
            return 3*Fibonacci(n-3)+2*Fibonacci(n-4);
    }

8.（ 同上）一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
(n=1：1种；n=2：2种；n=3：3种；n=4：5种…是个特殊的斐波那契函数)

var numWays = function(n) {
    if(n===0){
        return 1;
    }
    if(n<=3){
        return n;
    }
    var f=[BigInt(1),BigInt(2),BigInt(3)];
    for(let i=3;i<n;i++){
        f[i]=f[i-2]+f[i-1];
    }
    return f[n-1] % BigInt(1000000007);
};

9.（ 升级版跳台阶）一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
（大概从0级台阶到n级台阶，依次为0，1，2，4，8，16…2^(n-1) (n>=2)种）

function jumpFloorII(number)
{
    // write code here
    if(number===0){
        return 0
    }
    var x=1;
    for(let i=1;i<number;i++){
        x=x*2
    }
    return x
}
//递归方法
function jumpFloorII(number)
{
    // write code here
    if(number===0){
        return 0
    }
    if(number===1){
        return 1
    }
    if(number>0){
        return 2*jumpFloorII(number-1)
    }
}

10.（ 矩形）我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2n的大矩形，总共有多少种方法？
比如n=3时，23的矩形块有3种覆盖方法：
（n=1时：1个； n=2时：0个；n=3时：3个；n=4时：5个；n=5时：8个…还是斐波那契函数）

function rectCover(number)
{
    // write code here
    var n=[1,2];
    if(number===0){
        return 0
    }
    if(number <=2){
        return number
    }
    for(let i=2;i<number;i++){
        n[i]=n[i-2]+n[i-1]
    }
    return n[number-1];
}
//递归方法(太花时间)
function rectCover(number)
{
    // write code here
    if(number===0){
        return 0
    }
    if(number <=2){
        return number
    }
    if(number>2){
        return rectCover(number-2)+rectCover(number-1)
    }
}