0509练习

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

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int val){
        this.val=val;
    }

    @Override
    public String toString() {
        return "TreeNode{" +
                "val=" + val +
                ", left=" + left +
                ", right=" + right +
                '}';
    }
}

package mathtest;

import java.util.Arrays;

public class TreeNodeTest {
    public static TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        if (pre.length == 0 || in.length == 0) {
            return null;
        }
        TreeNode treeNode = new TreeNode(pre[0]);
        for (int i = 0; i < in.length; i++) {
            if (in[i] == pre[0]) {
                treeNode.left = reConstructBinaryTree(Arrays.copyOfRange(pre, 1, i + 1), Arrays.copyOfRange(in, 0, i));
                treeNode.right = reConstructBinaryTree(Arrays.copyOfRange(pre, i + 1, pre.length), Arrays.copyOfRange(in, i + 1, in.length));
                break;
            }
        }
        return treeNode;
    }
    public static void main(String[] args) {
        int[] pre={1,2,4,7,3,5,6,8};
        int[] in={4,7,2,1,5,3,8,6};
        System.out.println(reConstructBinaryTree(pre,in));
    }
}

用两个栈来实现一个队列，完成队列的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.Arrays;
public class Solution {
    public int minNumberInRotateArray(int [] array) {
        if(array.length ==0 || array == null){
            return 0;
        }
        Arrays.sort(array);
        return array[0];
    
    }
}

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

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

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

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

    }
}

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

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

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

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

    }
}

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

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Solution {
    public int NumberOf1(int n) {
   int length=0;
       String s =Integer.toBinaryString(n);
        Pattern p = Pattern.compile("1{1,}");
        Matcher m = p.matcher(s);
        while (m.find()){
            length+=m.group().length();
        }
       return length ;
    }
}

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

public class Solution {
    public double Power(double base, int exponent) {
       double temp =0;
        if(base == 0) return 0;
        if(exponent == 0) return 1;
        if(exponent == 1) return base;
        int abs = Math.abs(exponent);
        if(abs > 0){
            temp = Power(base,abs/2);
            temp= Math.abs(abs)%2 ==0?temp*temp:temp*temp*base;
        }
        if(exponent < 0){
            return 1/temp;
        }
        return  temp;
  }
}

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

import java.util.ArrayList;
import java.util.List;
public class Solution {
    public void reOrderArray(int [] array) {
     if(array.length ==0 || array == null){
            System.out.println("数组没有元素");
        }
        List<Integer> list1 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();
        for(int i=0;i<array.length;i++){

            if(array[i]%2 !=0){
             list1.add(array[i]);
            }else {
              list2.add(array[i]);  
            }
        }
        list1.addAll(list2);
        for(int i=0;i<list1.size();i++){
            array[i]=list1.get(i);
            System.out.println(array[i]);
        }
        
    }
}