牛客网剑指offer习题

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

（1）.使用递归方法

/使用递归进行处理
import java.util.ArrayList;
public class Solution {
    ArrayList<Integer> arraylist=new ArrayList<Integer>();//实例化一个数组列表arraylist
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        if(listNode!=null){//当列表不为空
            this.printListFromTailToHead(listNode.next);//使用递归
                arraylist.add(listNode.val);//将listNode的值放入arraylist中
            
        }
        return arraylist;//返回arraylist
    }

（2）.使用栈进行，将链表中的数先放入一个栈中，再将栈中的数依次输出

//使用栈进行处理
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
    ArrayList<Integer> arraylist=new ArrayList<Integer>();//实例化一个数组列表arraylist
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        Stack<Integer> stack=new Stack<Integer>();//实例化一个栈
        if (listNode==null){//当listNode中为空
            ArrayList list=new ArrayList();
            return list;
        }
        while (listNode!=null){//当listNode不为空
            stack.push(listNode.val);//将listNode中的值放入栈中
            listNode=listNode.next;
        }
        while(!stack.isEmpty()){//当栈中不为空
            arraylist.add(stack.pop());//将栈中的值输出放入arraylist中
        }
        return arraylist;//返回数组列表
    }
}

（3）.头插法

//使用栈进行处理
import java.util.ArrayList;
import java.util.Stack;
public class Solution {
    ArrayList<Integer> arraylist=new ArrayList<Integer>();
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        while(listNode!=null){
            arraylist.add(0,listNode.val);
            listNode=listNode.next;
        }
        return arraylist;
    }
}

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

public class Solution {
    public String replaceSpace(StringBuffer str) {

    String sti=str.toString();//转换为字符串
    char []strChar=sti.toCharArray();//转换为字符串数组
     StringBuffer out =new StringBuffer();//字符数组输出对象
        
        for(int i=0;i<strChar.length;i++){//遍历字符串数组
            if(strChar[i]==' ')//当第个字符为空格
                out.append("%20");//则在输出中增加%20
            else
                out.append(strChar[i]);//若不是则原样输出
        }
        return out.toString();//返回字符串
    }
}

3.在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
1.从矩阵的左下角开始比较，当目标值小于左下角的值，则行减，当目标值大于左下角的值，则列加，当目标值等于左下角的值，则输出。

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

（2）.使用暴力方法对二维数组进行遍历

public class Solution {
    public boolean Find(int target, int [][] array) {
        for(int i=0;i<array.length;i++){//遍历矩阵的行
            for(int j=0;j<array[0].length;j++){//遍历矩阵的列
                if(array[i][j]==target){//当目标值等于array[i][j]
                    return true;//返回true
                }
            }
        }
        return false;//否则返回错误
    }
}

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

public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        TreeNode root=reConstructBinaryTree(pre,0,pre.length-1,in,0,in.length-1);
        return root;
    }
    //前序遍历{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}
    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]);//pre[startPre]表示前序遍历中的第一个节点即根节点
         
        for(int i=startIn;i<=endIn;i++)//遍历中序遍历中的每个节点
            if(in[i]==pre[startPre]){//当中序遍历中的第i个值等于前序遍历中的第一个值则递归构造左右两个子树
                root.left=reConstructBinaryTree(pre,startPre+1,startPre+i-startIn,in,startIn,i-1);
                //pre表示前序遍历的列表，starPre+1表示前序遍历中左子树的第一个节点，即左子树中的根节点；starPre+i-startIn表示前序遍历中的左子树的长度；
                //in表示中序遍历，startIn表示中序遍历中的第一个节点；i-1表示中序遍历中的左子树的长度。
                //i-starin是在计算当前节点左子树节点个数。i-starin+starpre是确定当前节点左子树在pre里的位置.
                //先序序列长度和中序序列长度一定要相同，而中序序列的边界是比较好确定的，左子树中中序序列起点是startIn,终点是i-1，
                //左子树中先序序列起点是startPre+1,要求左子树先序序列终点，假设该终点下标为x,根据中序序列长度和先序序列长度相等的条件，
                //得到x-(startPre+1)=i-1-startIn,求得x=i-startIn+startPre
                root.right=reConstructBinaryTree(pre,i-startIn+startPre+1,endPre,in,i+1,endIn);
                //i-startIn+startPre+1表示中序遍历中第i个节点的左子树在前序遍历中的位置，endPre表示前序遍历中的最后一个值；i+1表示中序遍历中右子树中的左节点。
                      break;
            }
                 
        return root;
    }
}

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

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(stack1.empty()&&stack2.empty()){//当队列为空
            throw new RuntimeException("queue is null");
        }
        if(stack2.empty()){//当栈1不为空，栈2空
            while(!stack1.empty()){
                stack2.push(stack1.pop());
            }
        }
    return stack2.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) {
        int low=0;
        int highe=array.length-1;
        while(low<highe){
            int mid=low+(highe-low)/2;
            if(array[mid]>array[highe]){
                low=mid+1;
            }
            else if(array[mid]==array[highe]){
                highe=highe-1;
            }
            else if(array[mid]<array[highe]){
                highe=mid;
            }
        }
        return array[low];
    }
}

采用二分法解答这个问题，
mid = low + (high - low)/2
需要考虑三种情况：
(1)array[mid] > array[high]:
出现这种情况的array类似[3,4,5,6,0,1,2]，此时最小数字一定在mid的右边。
low = mid + 1
(2)array[mid] == array[high]:
出现这种情况的array类似 [1,0,1,1,1] 或者[1,1,1,0,1]，此时最小数字不好判断在mid左边
还是右边,这时只好一个一个试 ，
high = high - 1
(3)array[mid] < array[high]:
出现这种情况的array类似[2,2,3,4,5,6,6],此时最小数字一定就是array[mid]或者在mid的左
边。因为右边必然都是递增的。
high = mid
注意这里有个坑：如果待查询的范围最后只剩两个数，那么mid 一定会指向下标靠前的数字
比如 array = [4,6]
array[low] = 4 ;array[mid] = 4 ; array[high] = 6 ;
如果high = mid - 1，就会产生错误， 因此high = mid
但情形(1)中low = mid + 1就不会错误
另一种方法是对数组进行遍历，找出值最小的元素。

public class Solution {
    public int minNumberInRotateArray(int [] array) {
        if(array.length==0){
            return 0;
        }
        for(int i=0;i<array.length-1;i++){
            if(array[i]>array[i+1]){
                return array[i+1];
            }
        }
        return array[0];
    }
}

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

public class Solution {//使用递归进行处理
    public int Fibonacci(int n) {
        if(n==0){
            return 0;
        }
        else if(n==1){
            return 1;
        }
        else if(n==2){
            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;
        }
        else if(target==1){
            return 1;
        }
        else if(target==2){
            return 2;
        }
        else {
            return JumpFloor(target-1)+JumpFloor(target-2);
        }
    }
}

public class Solution {//使用自底向上，迭代操作
    public int JumpFloor(int target) {
        if(target==0){
            return 0;
        }
        else if(target==1){
            return 1;
        }
        int s1=1;
        int s2=1;
        int result=0;
        for(int i=2;i<=target;i++){
            result=s1+s2;
            s2=s1;
            s1=result;
        }
        return result;
        }
    }

该题是一个斐波那契数列的变形题，当只有一个台阶时，只有一种方法，有两个台阶时，由于青蛙每次可以跳一个台阶也可以同时跳两个台阶。所以有两种方法。对于有n个台阶时，一次可以跳一个或者两个。当要跳第n个台阶时，可以从第n-1个台阶跳，只需要跳一个台阶到达第n个台阶；也可以从第n-2个台阶跳，跳两个台阶到达第n个台阶。假设有n个台阶时，有f（n）种方法。从第n-1台阶跳时，n-1个台阶有f（n-1）种方法；当从第n-2个台阶跳时，n-2个台阶有f（n-2）种方法。因此在跳第n个台阶时，有f（n）=f（n-2）+f（n-1）种方法，是一个斐波那切数列。
9.一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

public class Solution {
    public int JumpFloorII(int target) {//使用递归自顶向下进行
        if(target==0){
            return 0;
        }
        else if(target==1){
            return 1;
        }
        else {
            return 2*JumpFloorII(target-1);
        }
    }
}

该题是跳台阶的变形题，因为原始的跳台阶题目中，青蛙一次只能跳一个或两个台阶，所以当要跳第n个台阶时可以从第n-1个台阶跳，也可以从第n-2个台阶跳。设跳第n个台阶时有f（n）种方法，所以跳到第n-1个台阶时有f（n-1）种方法，跳到第n-2个台阶时有f（n-2）种方法。所以要跳到第n个台阶时有f（n-1）+f（n-2）种方法。由此推得，在该题中，要跳到第n个台阶时有f（n-1）+f（n-2）+f（n-3）+…+f（n-n）=f（n）种方法。当调到第n-1个台阶时有f（n-1）= f（n-2）+f（n-3）+…+f（n-n）种方法，所以可知f（n）=2* f（n-1）种方法。当台阶数为0，则有0种方法，台阶数为1，有1种方法。n>=2时，f（n）=2f（n-1）种方法。
10. 我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2n的大矩形，总共有多少种方法？
比如n=3时，2*3的矩形块有3种覆盖方法：

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

该题是斐波那契数列的变形题，当n=1，只有一种构造的方法；当n=2，是在n=1的基础上再添加一个小矩形，有横竖两种方法构造；当n=3，是在n=2的基础上再添加一个小矩形，有三种方法构造；n=4，是在n=3的基础上再添加一个小矩形，有五种方法，可以推得当大矩形长为n，则有f（n-1）+f（n-2）种方法构造大矩形。
或者假设2 * n的大矩形的构造方法有f（n）种，当最顶部是一个小矩形横着放，则剩余的小矩形数量为n-1个，则构造剩余n-1个小矩形构成的大矩形的方法有f（n-1）种；当最顶部是两个小矩形竖着放，则剩余的小矩形数量为n-2个，则构造剩余的n-2个小矩形购销横的大矩形的方法有f(n-2)种。所以将这两种情况的方法数量相加就是2*n的大矩形的构造方法数量。f（n）=f（n-1）+f（n-2），则通过递归的方法进行构造。
11.输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

public class Solution {
    public int NumberOf1(int n) {
        int flage=1;
        int count=0;
        while(flage!=0){
            if((n&flage)!=0){
                count++;
            }
            flage=flage<<1;
        }
        return count;
    }
}

该题中使用一个标记位和该整数的二进制形式进行与运算，设该标记位为1，当该标记位不为零，如果该标记位和该二进制数在这一位的与运算不为零，则说明该位是1，然后将标记位左移一位，进行循环比较，如果与运算的结果不为零，则加一，直到将二进制数的所有位都比较完，输出最后得到的1的个数。