javascript剑指offer编程练习#3

第十一题

题目描述
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

function NumberOf1(n)
{    
    if(n<0){
        n=n>>>0
    }
    var arr=n.toString(2).split('')
    return arr.reduce((a,c)=>c==="1"?a+1:a,0)
}

按位操作符>>>的功能为将第一个操作数向右移动指定的位数。向右被移出的位被丢弃，左侧用0填充。因为符号位变成了 0，所以结果总是非负的。
reduce()为累加器方法，在计数时很方便。

第十二题

题目描述
给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

function Power(base, exponent)
{
    return Math.pow(base,exponent)
}

第十三题

题目描述
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

function reOrderArray(array)
{
    var odd=[]
    var even=[]
    array.forEach(i=>{
        if(i%2===0){
            even.push(i)
        }else{
            odd.push(i)
        }
    })
    return odd.concat(even)

}

第十四题

题目描述
输入一个链表，输出该链表中倒数第k个结点。

/*function ListNode(x){
    this.val = x;
    this.next = null;
}*/
function FindKthToTail(head, k)
{
    if(!head){
        return null
    }
    var arr=[]
    var temp=head
    while(temp){
        arr.push(temp)
        temp=temp.next
    }
    return arr.reverse()[k-1]
}

第十五题

题目描述
输入一个链表，反转链表后，输出新链表的表头。

/*function ListNode(x){
    this.val = x;
    this.next = null;
}*/
function ReverseList(pHead)
{   
    var prev,next
    if(!pHead){
        return null
    }
    while(pHead){
        next=pHead.next;
        pHead.next=prev;
        prev=pHead;
        pHead=next;
    }
    return prev
}

第十六题

题目描述
输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

/*function ListNode(x){
    this.val = x;
    this.next = null;
}*/
function Merge(pHead1, pHead2)
{
    if(!pHead1){
        return pHead2
    }else if(!pHead2){
        return pHead1
    }
    let cur1=pHead1,cur2=pHead2
    let curr={}
        if(cur1.val<=cur2.val){
            curr=cur1
            curr.next=Merge(cur1.next,cur2) 
        }else{
            curr=cur2
            curr.next=Merge(cur1,cur2.next)    
        }
    return curr

}

利用递归的方法，求得新的链表

第十七题

题目描述
输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

/* function TreeNode(x) {
    this.val = x;
    this.left = null;
    this.right = null;
} */
function HasSubtree(pRoot1, pRoot2)
{
 if(pRoot1 == null || pRoot2 == null){
        return false;
    }
    if(isSubTree(pRoot1, pRoot2)){
        return true;
    } else{
        return HasSubtree(pRoot1.left, pRoot2) || HasSubtree(pRoot1.right, pRoot2);
    }

    function isSubTree(node1,node2){
           if(!node2)return true
        if(!node1)return false
    
        if(node1.val===node2.val){
            return isSubTree(node1.left,node2.left) && isSubTree(node1.right,node2.right)
        }else{
            return false
        }
   
    }

}

新建一个isSubTree()方法，用来判断是不是两颗完全相同的树，再递归判断A，A的左子树或者A的右子树是否与B完全相等。

第十八题

题目描述
操作给定的二叉树，将其变换为源二叉树的镜像。
输入描述:
二叉树的镜像定义：源二叉树

8
/ \
6 10
/ \ / \
5 7 9 11
镜像二叉树
8
/ \
10 6
/ \ / \
11 9 7 5

/* function TreeNode(x) {
    this.val = x;
    this.left = null;
    this.right = null;
} */
function Mirror(root)
{
    // write code here
    if(!root){
        return null
    }
    let temp=root.left
    root.left=root.right
    root.right=temp
     if(root.left){
        Mirror(root.left);
    }
    if(root.right){
        Mirror(root.right);
    }
}

仍然是递归调用

第十九题

题目描述
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

  function printMatrix(matrix)
    {
        // write code here
        if(!matrix){
            return null
        }
        var result=[]
        while(matrix.length>1){
            result.push(...matrix[0])
            matrix.shift()
            matrix=rotate(matrix)
        }
        result.push(...matrix[0])

        function rotate(arr){
            let col=arr[0].length
            let row=arr.length
            let newarr=[]
            for(let i=0;i<col;i++){
                let newcol=[]
                for(let j=0;j<row;j++){
                    newcol.push(arr[j][i])
                }
                newarr.push(newcol)
            }
            return newarr.reverse()
        }
        return result

    }

非常有趣的一道题，思路如下：
1  2  3  4
5  6  7  8
9  10 11 12
13 14 15 16
取出第一排元素，将剩下的数组逆时针旋转90度
5  6  7  8
9  10 11 12 =>
13 14 15 16

8 12 16
7 11 15
6 10 14
5  9  13
继续取出该二维数组第一排元素后，旋转，直到数组为空

第二十题

题目描述
定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。

var stack=[]
function push(node)
{
    // write code here
    stack.push(node)
}
function pop()
{
    // write code here
    return stack.pop()
}
function top()
{
    // write code here
    return stack[stack.length-1]
}
function min()
{
    // write code here
    return Math.min.apply(null,stack)
}

第二十一题

题目描述
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）

function IsPopOrder(pushV, popV)
{
    // write code here
    if(!pushV.length||!popV.length){
        return false
    }
    let stack=[]
    let index=0
    for(let i=0;i<pushV.length;i++){
        stack.push(pushV[i])
        while(stack.length&&stack[stack.length-1]==popV[index]){
            stack.pop()
            index++
        }
    }
    return stack.length==0
}	

此题的关键在于构造辅助栈，判断栈顶元素是不是出栈顺序的第一个元素。如果相等，将相等的元素移除，继续对比