剑指Offer刷题【JAVA】，重温算法经典，找回年少时的自己，持续更新中........

代码地址：https://gitee.com/luzequanmace/offer.git

1、二维数组中的查找

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

public class Solution {
    public boolean Find(int target, int [][] array) {
        //判断是否为空
        if(array == null || array.length == 0 || array[0].length == 0){
            return false;
        }
        //从右上角向左下角遍历
        int rows = array.length; 
        int columns = array.length;
        int r = 0;
        int c = columns - 1;
        while(r <= rows - 1 && c >= 0){
            if(target == array[r][c]){
                return true;
            }else if(target > array[r][c]){
                r ++;
            }else{
                c --;
            }
        }
        return false;
    }
}

2、替换空格

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

public class Solution {
    public String replaceSpace(StringBuffer str) {
    	 return str.toString().replaceAll("\\s","%20");
    }
}

3、从头到尾打印链表

题目描述
输入一个链表，按链表从尾到头的顺序返回一个ArrayList。

import java.util.ArrayList;
import java.util.Stack;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> res = new ArrayList<>();
        Stack<Integer> stack = new Stack<Integer>();
        //先把数据放进栈中
        while(listNode != null){
            stack.push(listNode.val);
            listNode = listNode.next;
        }
        //从栈中取数据
        while(!stack.isEmpty()){
            res.add(stack.pop());
        }
        return res;
    }
}

4、从头到尾打印链表

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

必备知识点：
1.递归知识
2.Arrays工具类的使用

解题思路：
1、pre[]前序遍历的第一个节点是根节点 == in[]中序遍历的根节点 由此可以分出pre[] in[]左子树和右子树
2、pre[]左子树的前序遍历的第一个节点是根节点 == 是in[]中序遍历的左子树的根节点
3、pre[]右子树的前序遍历的第一个节点是in[]中序遍历的右子树的根节点
4、依次递归。。。。。。

import java.util.Arrays;
public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        //如果数组为空，那么就结束
        if(pre.length == 0 || in.length == 0){
            return null;
        }
        //找出根节点，根节点为pre[]前序遍历的第一个节点
        TreeNode root = new TreeNode(pre[0]);
        //通过循环找出in[]中序遍历的根节点，因为数组不重复，所以中序遍历的根节点 == pre[0]
        for(int i = 0; i < in.length; i ++){
            //in[]根节点的条件
            if(in[i] == pre[0]){
               //递归 ，传入条件pre[]左子树，in[]左子树，这两个条件同样符合以上的规律
               root.left = reConstructBinaryTree(Arrays.copyOfRange(pre,1,i + 1),Arrays.copyOfRange(in,0,i));
               //递归 ，传入条件pre[]右子树，in[]右子树，这两个条件同样符合以上的规律
               root.right = reConstructBinaryTree(Arrays.copyOfRange(pre,i + 1,pre.length),Arrays.copyOfRange(in,i + 1, in.length));
            }
        }
        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) {
        if(stack2 != null){
            int size2 = stack2.size();
            for(int i = 0; i < size2; i ++){
                stack1.push(stack2.pop());
            }
        }
        stack1.push(node);
        int size1 = stack1.size();
        for(int i = 0; i < size1; i ++){
            stack2.push(stack1.pop());
        }
    }
    
    public int pop() {
        return stack2.pop();
    }
}

6、旋转数组中的最小数字

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

思路：二分法主要是判断目标数在数组左边还是数组右边
二分法的难点在于细节：其实很简单
1、left可能会和mid指针重合，但是right指针不可能和mid指针重回
2、举列子，情况一：1,2 left和mid指针指向1，right指向2。然后在往下推算一两步就行。
3、情况二：2,1 left和mid指针指向2，right指向1。然后在往下推算一两步就行。
4、根据以上两种情况可以判断中止条件是l <= r 还是 l < r 返回的是array[mid]还是array[l]等等…

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

7、斐波那契数列

题目描述
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。
n<=39

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

8、跳台阶

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

public class Solution {
    public int JumpFloor(int target) {
        if(target < 3) return target;
        int[] dp = new int[target + 1];
        dp[1] = 1;
        dp[2] = 2;
        for(int i = 3; i < dp.length; i ++){
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[target];
    }
}

9、变态跳台阶

题目描述
一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

public class Solution {
    public int JumpFloorII(int target) {
       if(target < 3) return target;
       int[] dp = new int[target + 1];
       dp[0] = 1;
       dp[1] = 1;
       dp[2] = 2;
       for(int i = 3; i < dp.length; i ++){
           //第n阶台阶可以从第0，1，2，3，......,n-1阶跳上来
           for(int j = 0; j < i; j ++){
               dp[i] += dp[j];
           }
       }
       return dp[target];
    }
}

10、矩形覆盖

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

比如n=3时，2*3的矩形块有3种覆盖方法：

public class Solution {
    public int RectCover(int target) {
        if(target < 3) return target;
        int[] dp = new int[target + 1];
        dp[1] = 1;
        dp[2] = 2;
        for(int i = 3; i < dp.length; i++){
            dp[i] = dp[i - 1] + dp[i - 2];
        }          
        return dp[target];
    }
}

11、二进制中一的个数

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

public class Solution {
    public int NumberOf1(int n) {
        int counter = 0;
        while(n != 0){
            n &= n - 1;
            counter ++;
        }
        return counter;
    }
}