剑指offer

最新推荐文章于 2024-03-19 10:30:28 发布

BigDaddy2333

最新推荐文章于 2024-03-19 10:30:28 发布

阅读量127

点赞数 1

本文链接：https://blog.csdn.net/qq_41720311/article/details/86471142

版权

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

function Find(target, array)
{
    var rowCount = array.length - 1 , i , j ;
    for(i = rowCount,j = 0 ; i >= 0 && j < array[i].length;){
        if(target == array[i][j]){
            return true;
        }else if(target > array[i][j]){
            j++;
            continue;
        }else if(target < array[i][j]){
            i--;
            continue;
        }
    }
    return false;
}

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

function replaceSpace(str)
{
    return str.replace(/ /g,'%20');
}

3.输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。

/*function ListNode(x){
    this.val = x;
    this.next = null;
}*/
function printListFromTailToHead(head)
{
    if(!head){
        return 0;
    }else{
        var arr = new Array();
        var curr = head;
        while(curr){
            arr.push(curr.val);
            curr = curr.next;
        }
        return arr.reverse();
    }
}

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

/* function TreeNode(x) {
    this.val = x;
    this.left = null;
    this.right = null;
} */
function reConstructBinaryTree(pre, vin)
{
    if(pre.length == 0 || vin.length == 0){
        return null;
    };
    var index = vin.indexOf(pre[0]);
    var left = vin.slice(0,index);
    var right = vin.slice(index+1);
    var node = new TreeNode(vin[index]);
    node.left = reConstructBinaryTree(pre.slice(1,index+1),left);
    node.right = reConstructBinaryTree(pre.slice(index+1),right);
    return node;
}

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

var stack1 = [];
var stack2 = [];

function push(node){
    stack1.push(node);//压入栈1
}

function pop(){
    var temp = stack1.pop();//从栈1中的一个数据弹出来存到变量中
    while(temp){
        stack2.push(temp);//把弹到变量中的那一个数据压入栈2中
        temp = stack1.pop();//再继续弹下一个数据
    }
    var result = stack2.pop(); //把栈2的数据弹出来 
    temp = stack2.pop();
    while(temp){
	stack1.push(temp);
	temp = stack2.pop();
}
    return result;
}

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

function minNumberInRotateArray(rotateArray){
    var len = rotateArray.length;
    if(len === 0){
        return 0;
    }
    return Math.min.apply(null,rotateArray);
}

7.大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。

n<=39

function Fibonacci(n){
    var a = 1, b = 1, temp;
    if(n <= 0) return 0;
    for(var i = 2; i <= n; i++){
      temp = b;
      b = a + b;
      a = temp;
    }
    return a;
}

8.一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）

function jumpFloor(number){
    if(number < 1){
        return 0;
    }
    if(number === 1){
        return 1;
    }
    if(number === 2){
        return 2;
    }
    var temp = 0, a = 1, b = 2;
    for(var i = 3; i <= number; i++){
        temp = a + b;
        a = b;
        b = temp;
    }
    return temp;
}

9.我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

function rectCover(number){
    var a = 1, b = 2, temp;
    if(number <= 0){
        return 0;
    }
    if(number === 1){
        return 1;
    }
    if(number === 2){
        return 2
    }
    for(var i = 3; i <= number; i++){
      temp = a + b;
      a = b;
      b = temp;
    }
    return temp;
}

10.输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

function NumberOf1(n)
{
    if(n < 0){
        n = n>>>0;
    }
    var arr = n.toString(2).split('');
    return arr.reduce(function(a,b){
        return b === "1" ? a + 1 : a;
    },0)
    
}
/*
array.reduce(function(total,currentValue,currnetIndex,arr),initialValue)
total 必需，初始值 或者计算结束后的返回值，
currentValue 必需，当前元素
initialValue 可选，传递给函数的初始值
*/

11.给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

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

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

function reOrderArray(array)
{
    var result = [];
    var even = [];
    array.forEach(function(item){
        if(item % 2 !== 0){
            result.push(item);
        }else{
            even.push(item);
        }
    });
    return result.concat(even);
}

13.输入一个链表，输出该链表中倒数第k个结点。

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

14.输入一个链表，反转链表后，输出新链表的表头。

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

15.

操作给定的二叉树，将其变换为源二叉树的镜像。

输入描述:

二叉树的镜像定义：源二叉树 
    	    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)
{
    if(root == null){
        return null;
    }
    var temp = root.left;
    root.left = root.right;
    root.right = temp;
    Mirror(root.left);
    Mirror(root.right);
}

16.输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下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)
{
    var rows = matrix.length;
    var cols = matrix[0].length;
    if(rows == 0 || cols == 0){
        return [];
    }
    var top = 0,
        left = 0,
        right = cols - 1,
        bottom = rows - 1,  
        result = [];
    while(left <= right && top <= bottom){
        for(let i = left; i <= right; i++){
            result.push(matrix[top][i]);
        }
        for(let i = top+1; i <= bottom; i++){
            result.push(matrix[i][right]);
        }
        if(top!=bottom)
            for(let i = right-1; i >= left; i--){
                result.push(matrix[bottom][i]);
            }
        if(left != right)
            for(let i = bottom - 1;i >= top + 1 ;i--){
                result.push(matrix[i][left]);
            }
        left++;
        top++;
        right--;
        bottom--;
    }
    return result;
}

17.从上往下打印出二叉树的每个节点，同层节点从左至右打印。

/* function TreeNode(x) {
    this.val = x;
    this.left = null;
    this.right = null;
} */
function PrintFromTopToBottom(root)
{
    var arr = [];
    if(root == null){
        return [];
    }
    arr.push(root.val);
    function travel(root){
        if(root.left == null && root.right == null) return;
        if(root.left != null) arr.push(root.left.val)
        if(root.right != null) arr.push(root.right.val)
        if(root.left != null) travel(root.left);
        if(root.right != null) travel(root.right);
    }
    travel(root);
    return arr;
}

18.求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

function Sum_Solution(n)
{
    var res = n;
    (n>0)&&(res += Sum_Solution(n-1));
    return res;
}

19.写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号.

function Add(num1, num2)
{
    // write code here
    var sum,ad;
    do{
        sum=num1^num2;
        ad=(num1&num2)<<1;
        num1=sum;
        num2=ad;
    }while(num2)
        return sum;
}

20.请实现一个函数用来匹配包括'.'和'*'的正则表达式。模式中的字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（包含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但是与"aa.a"和"ab*a"均不匹配

function match(s, pattern)
{
    var reg=new RegExp("^" + pattern + "$");
    return reg.test(s);
}

21.在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。例如，链表1->2->3->3->4->4->5 处理后为 1->2->5

/*function ListNode(x){
    this.val = x;
    this.next = null;
}*/
function deleteDuplication(pHead)
{
    // write code here
    if(pHead==null||pHead.next==null) return pHead;
    var first={
        val:0,
        next:pHead
    }
    var head=pHead,pre=first;
    while(head!=null&&head.next!=null){
        if(head.val==head.next.val){
            while(head.next&&head.next.val==head.val){
                head=head.next;               
            }
            pre.next=head.next;
        }else{
            pre.next=head;
            pre=pre.next;
        }
        //pre=head;
        head=head.next;

    }
    return first.next;
}

22.