剑指offer11-20（JavaScript）

11、二进制中1的个数

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

思路：n>0时先转换成字符串，再添加前导0构成32位二进制数，循环计数1的个数；

           n<0时先转换成字符串，添加前导0构成32位二进制数，然后将0变成1,1变成0（相当于取反），转换成整数并加一，然后再次转换成字符串并记录1的个数。

function NumberOf1(n)
{
    if(n===0){
        return 0;
    }
    else if(n>0){
        var str=n.toString(2);
        str=str.padStart(32,0);
        var num=0;
        for(var i=0;i<str.length;i++){
            if(str[i]==='1'){
                num++;
            }
        }
        return num;
    }
    else{
        n=-n;
        var str2=n.toString(2);
        str2=str2.padStart(32,0);
        var str3='';
        for(var j=0;j<str2.length;j++){
            if(str2[j]==='0'){
                str3+='1';
            }
            else{
                str3+='0';
            }
        }
        var number=parseInt(str3,2);
        number=number+1;
        var s=number.toString(2);
        var num=0;
        for(var k=0;k<s.length;k++){
            if(s[k]==='1'){
                num++;
            }
        }
        return num;
    }
}

12、数值的整数次方

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

思路：循环乘法代替指数运算，指数为负数时要取倒数。

function Power(base, exponent)
{
    if(exponent===0){
        return 1;
    }
    else if(exponent>0){
        var b=1;
        for(var i=0;i<exponent;i++){
            b=b*base;
        }
        return b;
    }
    else{
        exponent=-exponent;
        var c=1;
        for(var i=0;i<exponent;i++){
            c=c*base;
        }
        c=1/c;
        return c;
    }
}

13、调整数组顺序使奇数位于偶数前面

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

思路：将奇数和偶数项分别存在两个数组中，然后连接两个数组。

function reOrderArray(array)
{
    var head=[],tail=[];
    for(var i=0,n=array.length;i<n;i++){
        if(array[i]%2===0){
            tail.push(array[i]);
        }
        else{
            head.push(array[i]);
        }
    }
    head=head.concat(tail);
    return head;
}

14、链表中倒数第K个节点

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

思路：将链表节点从头到尾放入数组中，输出数组的第n-k项。

function FindKthToTail(head, k)
{
    var arr=[];
    while(head!==null){
        arr.push(head);
        head=head.next;
    }
    var n=arr.length;
    return arr[n-k];
}

15、反转链表

题目描述：输入一个链表，反转链表后，输出链表的所有元素。

思路：利用数组的unshift方法将链表各节点逆序存入数组中，用 arr[i].next.next=arr[i] 即可反转链表。

function ReverseList(pHead)
{
    if(pHead===null){
        return null;
    }
    var arr=[];
    while(pHead!==null){
        arr.unshift(pHead);
        pHead=pHead.next;
    }
    for(var i=1,n=arr.length;i<n;i++){
        arr[i].next.next=arr[i];   //1->2->3->4->5   4.next=5  用5.next=4即可反转
    }
    arr[n-1].next=null
    return arr[0];
}

16、合并两个排序链表

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

/*function ListNode(x){
 this.val = x;
 this.next = null;
 }*/
function Merge(pHead1, pHead2)
{
    var hh,h;
    if(pHead1===null&&pHead2===null){
        return null;
    }else if(pHead1===null){
        return pHead2;
    }else if(pHead2===null){
        return pHead1;
    }else{
        if(pHead1.val>=pHead2.val){
            h=pHead2;
            pHead2=pHead2.next;
            hh=h;
        }
        else{
            h=pHead1;
            pHead1=pHead1.next;
            hh=h;
        }
    }


    while(pHead2!==null||pHead1!==null){
        if(pHead2===null){
            while(pHead1!==null) {
                h.next = pHead1;
                pHead1 = pHead1.next;
                h=h.next;
            }
            break;
        }
        else if(pHead1===null){
            while(pHead2!==null) {
                h.next = pHead2;
                pHead2 = pHead2.next;
                h=h.next;
            }
            break;
        }
        if(pHead1.val>=pHead2.val){
            h.next=pHead2;
            pHead2=pHead2.next;
            h=h.next;
        }
        else{
            h.next=pHead1;
            pHead1=pHead1.next;
            h=h.next;
        }
    }
    return hh;
}

17、树的子结构

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

思路：用递归法，先判断B是不是A的子结构，再判断B是不是A的左子树的子结构，最后判断B是不是A的右子树的子结构。

isSubtree函数中第一个参数为null说明A已经到叶子结点，故返回false，若第二个参数为null说明B已经到叶子结点，所有节点均能在A中找到，故返回true。

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

18、二叉树的镜像

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

思路：从根节点开始自顶向下交换每个节点的左右子树

/* function TreeNode(x) {
 this.val = x;
 this.left = null;
 this.right = null;
 } */
function Mirror(root)
{
    if(root===null){
        return null;
    }
    [root.left,root.right]=[root.right,root.left];
    Mirror(root.left);
    Mirror(root.right);
    return root;
}

19、顺时针打印矩阵

题目描述：输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下矩阵： 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)
{
    if (matrix == null || matrix.length == 0) {
        return;
    }
    var rows = matrix.length;
    var cols = matrix[0].length;
    var start = 0;
    var result = [];

    while (cols > start * 2 && rows > start * 2) {
        var endX = cols - 1 - start;
        var endY = rows - 1 - start;
        //从左到右打印一行
        for (var i = start; i <= endX; i++) {
            result.push(matrix[start][i]);
        }
        //从上到下打印一行
        if (start < endY) {
            for (var i = start + 1; i <= endY; i++) {
                result.push(matrix[i][endX]);
            }
        }
        //从右到左打印一行
        if (start < endX && start < endY) {
            for (var i = endX - 1; i >= start; i--) {
                result.push(matrix[endY][i]);
            }
        }
        //从下到上打印一行
        if (start < endX && start < endY - 1) {
            for (var i = endY - 1; i >= start + 1; i--) {
                result.push(matrix[i][start]);
            }
        }
        start++;
    }
    return result;
}

20、包含min函数的栈

题目描述：定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的min函数。

思路：用数组模拟栈，Math.min.apply(null,array)得带最小值。

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(this,stack);
}