一周刷完牛客网剑指offer 67题之1-11题（java代码）持续更新

牛客网剑指offer67题（1-11）

我这里就直接按它给的顺序写了，不再归类了。
（一）1-11题，最近事情比较多，要忙小论文的实验还要辅助老师完成研究生线上复试…所以就写这些练练手，这些题中应该第四题重建二叉树稍微步骤和代码量多一点，本科的时候也接触过了给定前序、中序遍历推出二叉树的题，从遍历原理入手理解的会更快。

1.二维数组中的查找

题目描述
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
思路
从题目描述可知，行是从左到右递增，列是从上到下递增，那么可以考虑从最右上角的数开始比较，小于它就往左移，大于它就往下移。

public class Solution {
    public boolean Find(int target, int [][] array) {
        int i=0,j=array[0].length-1;
        while(i<array.length&&j>=0){
            if(array[i][j]==target) return true;
            else if(array[i][j]>target) j--;
            else i++;
        }
        return false;
    }
}

2.替换空格

题目描述
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
思路
这里可以考虑直接构建一个新的字符进行存储，非空格就直接加入，否则替换加入。

public class Solution {
    public String replaceSpace(StringBuffer str) {
    	StringBuffer newStr =new StringBuffer();
        for(int i=0;i<str.length();i++){
            if(str.charAt(i)!=' ')
                newStr.append(str.charAt(i));
            else
                newStr.append("%20");
        }
        return newStr.toString();
    }
}

3.从尾到头打印链表

题目描述
输入一个链表，按链表从尾到头的顺序返回一个ArrayList。
思路
第一眼看过去以为是要链表逆置，其实链表逆置也是可以的，这里的话直接先创建list之后再逆置list好了。

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list=new ArrayList<>();
        while(listNode!=null){
            list.add(listNode.val);
            listNode=listNode.next;
        }
        for(int i=0;i<list.size()/2;i++){
            int temp=list.get(i);
            list.set(i,list.get(list.size()-1-i));
            list.set(list.size()-1-i,temp);
        }
        return list;
    }
}

4.重建二叉树

题目描述
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
思路
二叉树的前序遍历是根左右，中序遍历是左根右，那么可以找到根结点在中序遍历中的位置，也就可以把中序遍历中分为左子树和右子树，然后递归执行重构二叉树。

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
import java.util.HashMap;
public class Solution {
	private HashMap<Integer,Integer> map=new HashMap<>();
	public TreeNode reConstructBinaryTree(int[] pre, int[] in) {
	    for(int i = 0; i < in.length; i ++) {
	    	map.put(in[i], i);//key: in的值，value: 值在in中位置
	    }
		
		return getBiTree(pre, 0, pre.length - 1, 
							in, 0, in.length - 1);
	}
	
	private TreeNode getBiTree(int[] pre, int preLeft, int preRight, int[] in, int inLeft, int inRight) { 
	    if(preLeft == preRight) { //即根据前序遍历，当前结点无子结点
	    	return new TreeNode(pre[preLeft]);
	    }
	    if(preLeft > preRight || inLeft > inRight) {
	    	return null;
	    }
	    
	    TreeNode root = new TreeNode(pre[preLeft]);
	    int inIndex = map.get(root.val);
	    int leftTreeSize = inIndex - inLeft;//该结点左半部分的结点数
	    
	    //递归，获取左子树及右子树
	    root.left = getBiTree(pre, preLeft + 1, preLeft + leftTreeSize, in, inLeft, inIndex - 1);
	    root.right = getBiTree(pre, preLeft + 1 + leftTreeSize, preRight,in, inIndex + 1, inRight);
	    
	    return root;
	}
}

5.用两个栈实现队列

题目描述
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。
思路
栈是先进后出，队列是先进先出，如果用两个栈实现的话就需要将后面入栈的元素给他放到栈底，用两个栈来回入栈一次就好了。

import java.util.Stack;

public class Solution {
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();
    
    public void push(int node) {
        while(!stack1.isEmpty()){
            stack2.push(stack1.pop());
        }
        stack2.push(node);
        while(!stack2.isEmpty()){
            stack1.push(stack2.pop());
        }
    }
    
    public int pop() {
        return stack1.pop();
    }
}

6.旋转数组的最小数字

题目描述
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
思路
从旋转数组的性质可知，该数组由较大数的上半部分+较小数的下半部分组成，该数组的最小值不大于他前面一位元素值，直接按序查找理论是可以的，这里考虑使用二分查找会比较清晰一些。

import java.util.ArrayList;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        if(array.length==0) return 0;
        int left=0,right=array.length-1;
        while(array[left]>=array[right]){
            if(right-left==1) return array[right];
            int mid=left+(right-left)/2;
            if(array[mid]>=array[left]){
                left=mid;
            }else{
                right=mid;
            }
        }
        return 0;
    }
}

7.斐波那契数列

题目描述
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。
n<=39
思路
F(n)=F(n-1)+F(n-2),不用想了递归实现就完事。

public class Solution {
    public int Fibonacci(int n) {
        if(n==0) return 0;
        if(n==1) return 1;
        else return Fibonacci(n-1)+Fibonacci(n-2);
    }
}

8.跳台阶

题目描述
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
思路
类似斐波那契的思路，仍然从最后到达台阶开始往前推，因为不同顺序算不同方法，所以可以直接递归下去。

public class Solution {
    public int JumpFloor(int target) {
        if(target==0) return 0;
        if(target==1) return 1;
        if(target==2) return 2;
        else{
            return JumpFloor(target-1)+JumpFloor(target-2);
        }
        
    }
}

9.变态跳台阶

题目描述
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。
思路
这一题相对于上一题只是多了循环，因为从1-n青蛙都可以一次到达，通俗的说话就是跳上n级台阶的跳法是前面所有0-n-1级台阶跳法的总和。 （F(n)=F(n-1)+F(n-2)+···+F(n-n)）

public class Solution {
    public int JumpFloorII(int target) {
        if(target==1||target==0) return 1;
        if(target==2) return 2;
        int sum=0;
        for(int i=0;i<target;i++){
            sum+=JumpFloorII(i);
        }
        return sum;
    }
}

后来发现其实可以满足F(n)=2*F(n-1)

public class Solution {
    public int JumpFloorII(int target) {
        if(target<=0) return -1;
        if(target==1) return 1;
        else
            return 2*JumpFloorII(target-1);
    }
}

10.矩形覆盖

题目描述
我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？
思路
这就是换了个壳的斐波那契！！因为矩形只有两种放法，竖着根横着放，不信自己画一下覆盖规律。。。

public class Solution {
    public int RectCover(int target) {
        if(target==0) return 0;
        if(target==1) return 1;
        if(target==2) return 2;
        else{
            return RectCover(target-1)+RectCover(target-2);
        }
    }
}

11.二进制中1的个数

题目描述
输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。
思路
二进制求解中常用的就是使用位运算。

public class Solution {
    public int NumberOf1(int n) {
        int sum = 0;
		
		while(n != 0) {
			sum ++;
			n = n & (n-1);//&按位与
		}
		
		return sum;
    }
}

下一篇： 传送门：牛客网剑指offer 67题之12-21题