剑指offer_编程题_java版（1-10）

二维数组中的查找

题目描述
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
解题：
方法一：直接遍历二维数组，找到target
方法二：从二维数组右上角入手，即每行最大的数，代码如下

public class Solution {
    public boolean Find(int target, int [][] array) {
        int cols=array[0].length;//最大列
        int rows=array.length;//最大行
        int row=0;
        int col=cols-1;
        while(row<rows&&col>=0){
            int num=array[row][col];
            if(target>num){
                row++;
            }else if(target<num){
                col--;
            }else
                return true;
        }
       return false;
    }
}

替换空格

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

public class Solution {
    public String replaceSpace(StringBuffer str) {
        //方法一
    	//turn str.toString().replace(" ","%20")；
        //方法二
        StringBuffer sb=new StringBuffer();
        for(int i=0;i<str.length();i++){
            char c=str.charAt(i);
            if(c==' '){
                sb.append("%20");
            }else{
                sb.append(c);
            }
        }
        return sb.toString();
    }
}

从尾到头打印链表

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

/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.ArrayList;
public class Solution {
    //方法一
    public ArrayList<Integer> printListFromTailToHead1(ListNode listNode) {
        ArrayList<Integer> array=new ArrayList<>();
        while(listNode!=null){
            array.add(0,listNode.val);//通过该方法实现
            listNode=listNode.next;
        }
        return array;
    }
    //方法二,递归
    ArrayList<Integer> arrayList=new ArrayList<>();
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        if(listNode!=null){
            //先递归到最后一个节点，在从最后一个节点逐次添加到数组
            printListFromTailToHead(listNode.next);
            arrayList.add(listNode.val);
        }
        return arrayList;
    }
}

重建二叉树

题目描述
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{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; }
 * }
 */
/**
大致思路：
1.根据前序遍历找出根节点root=pre[0];
2.在中序遍历中找出根节点位置in[i]=root;
3.即中序遍历中根左边为左子树，根右边为右子树
4.左子树
    中序：0到i-1
    前序：1到i
5.右子树
    中序：i+1到in.length-1
    前序：i+1到pre.length-1
6.递归遍历
*/

public class Solution {
    //方法一，使用copyOfRange 函数，注意左闭右开
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        if (pre.length == 0 || in.length == 0) {
            return null;
        }
        TreeNode root = new TreeNode(pre[0]);
        // 在中序中找到前序的根
        for (int i = 0; i < in.length; i++) {
            if (in[i] == root.val) {
                // 左子树
                root.left = reConstructBinaryTree(
                    java.util.Arrays.copyOfRange(pre, 1, i + 1),
                     java.util.Arrays.copyOfRange(in, 0, i));
                // 右子树
                root.right = reConstructBinaryTree(
                    java.util.Arrays.copyOfRange(pre, i + 1, pre.length),
                    java.util.Arrays.copyOfRange(in, i + 1, in.length));
            }
        }
        return root;
    }   
    
    //方法二,不使用java.util.Arrays.copyOfRange（）
    public TreeNode reConstructBinaryTree1(int [] pre,int [] in) {
        return reConstructBinaryTree(pre,0,pre.length-1,in,0,in.length-1);
    }
    private TreeNode reConstructBinaryTree(int [] pre,
       int startpre,int endpre,int [] in,int startin,int endin) {
        if(startpre>endpre||startin>endin)
            return null;
        TreeNode root=new TreeNode(pre[startpre]);//找到根节点
        for(int i=startin;i<=endin;i++){
            if(root.val==in[i]){//找到根节点在中序遍历中位置
            root.left=reConstructBinaryTree
                (pre,startpre+1,startpre+i-startin,in,startin,i-1);
            root.right=reConstructBinaryTree
                (pre,i-startin+startpre+1,endpre,in,i+1,endin);
            }
        }
        return root;
    }
   
}

用两个栈实现队列

题目描述
用两个栈来实现一个队列，完成队列的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) {
        stack1.push(node);
    }
    
    public int pop() {
       if(stack2.empty()){
           while(!stack1.empty()){
               stack2.push(stack1.pop());
           }
       }
       return stack2.pop();
    }
}

旋转数组的最小数字

题目描述
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{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;
        }else{
            int min=array[0];
            for(int i=1;i<array.length;i++){
                if(min>array[i]){
                    min=array[i];
                }
            }
            return min;
        }
    }
}

斐波那契数列

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

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

跳台阶

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

//n=1时，1种
//n=2  , 2
//n=3  , 3
//n=4  , 5....
public class Solution {
    public int JumpFloor(int target) {
        return target<=2?target:JumpFloor(target-1)+JumpFloor(target-2);   
    }
}

变态跳台阶

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

/**
易知
f(n)=f(n-1)+f(n-2)+……f(1)
f(n-1)=f(n-2)+……f(1)
两式相减得
f(n)=2f(n-1)
*/
public class Solution {
    public int JumpFloorII(int target) {
        return target<=2?target:1<<(target-1);
    }
}

矩形覆盖

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

解题

public class Solution {
    public int RectCover(int target) {
        return target<=2?target:RectCover(target-1)+RectCover(target-2);
    }
}