牛客网刷题 第二轮

1.1 求二叉树的最大深度

public class Solution {
    public int TreeDepth(TreeNode root) {
        if(root == null){
            return 0;
      }else{
            return Math.max(TreeDepth(root.left) + 1,TreeDepth(root.right) + 1);
        }
    }
}

1.2 输入一棵二叉树，判断该二叉树是否是平衡二叉树。

• 思路：
  先写一个计算数深度的方法，递归去判断树的左右子树的深度差是否超过1，默认不超过。

package com.example.demo;

public class TrreeNode {
    public static void main(String[] args) {
        Node tree = Node.getTree();
        System.out.println(judke(tree));
    }
    public static int getTreeDeepth(Node node){
        if(node == null){
            return 0;
        }else {
            return Math.max(getTreeDeepth(node.left)+1,getTreeDeepth(node.right)+1);
        }
    }
    public static boolean judke(Node node){
        if(node == null){
            return true;
        }else {
            int left = 0;
            int right = 0;
            if(node.left != null){
                left = getTreeDeepth(node.left);
            }else {
                left = 0;
            }
            if(node.right != null){
                right = getTreeDeepth(node.right);
            }else {
                right = 0;
            }
            if(Math.abs(left - right) <= 1){
                return judke(node.left )&&judke(node.right);
            }else {
                return false;
            }
        }
    }
}

1.3 一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。

package com.example.demo;

public class FindNum {
    public static void main(String[] args) {

    }
    public static void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {
        if(array.length == 0){
            return;
        }
        int[] arr = new int[2];
        int j = 0;
        for (int i = 0; i < array.length; i++) {
            if(LastIndexOf(array,i)){
                if(j == 2){
                    break;
                }
                arr[j++] = array[i];
            }
        }
        num1[0] = arr[0];
        num2[0] = arr[1];
    }
    public static boolean LastIndexOf(int[] array, int find){
        int begin = -1;
        int end = -1;
        for (int i = array.length - 1; i >= 0; i--){
            if(array[i] == array[find]){
                end = i;
                break;
            }
        }
        for (int i = 0; i < array.length; i++) {
            if(array[i] == array[find]){
                begin = i;
                break;
            }
        }
        if(begin == end){
            return true;
        }else {
            return false;
        }
    }
}

1.4 输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序

• 将数分成偶数个序列组成和奇数个序列组成两种情况，分别计算开头的数，根据开头的数推出后面的数。

package com.example.demo;

import java.util.ArrayList;

public class AddSth {
    public static void main(String[] args) {
        ArrayList> array = getArray(100);
        for(ArrayList list : array){
            for(Integer integer : list){
                System.out.print(integer + " ");
            }
            System.out.println();
        }
    }
    public static ArrayList> getArray(int num){
        ArrayList> arrayLists = new ArrayList<>();
        for (int i = num; i > 1; i--) {
            if(i % 2 == 1){
                ArrayList array = getSingle(num, i);
                if(array != null){
                    arrayLists.add(array);
                }
            }else {
                ArrayList aDouble = getDouble(num, i);
                if(aDouble != null){
                    arrayLists.add(aDouble);
                }
            }
        }
        return arrayLists;
    }
    public static ArrayList getDouble(int num,int k){
        ArrayList arrayList = new ArrayList<>();
        //最中间的两个数的和必须是奇数，不是奇数则意味着不可能再分下去
        int flag = k / 2;
        if(num / flag % 2 != 1){
            return null;
        }
        //分成的每一组的和必须是整数(两个数一组)
        if(num % flag != 0){
            return null;
        }
        int mid_start = num / flag / 2;
        if(mid_start - flag + 1 <= 0){
            return null;
        }else {
            for (int i = 0; i < k; i++) {
                arrayList.add(mid_start - flag + 1 + i);
            }
        }
        return arrayList;
    }
    public static ArrayList getSingle(int num,int k){
        ArrayList arrayList = new ArrayList<>();
        //最中间的数必须是整数，不是整数则不行
        if(num % k != 0){
            return null;
        }else {
            //第一个数必须大于等于1，不然是错误的
            int mid = num / k;
            int reduce = k /2;
            if(mid - reduce <= 0){
                return null;
            }
            else {
                for (int i = 0; i < k; i++) {
                    arrayList.add(mid - reduce + i);
                }
                return arrayList;
            }
        }
    }
}

1.5 输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。

package com.example.demo;

import java.util.ArrayList;

public class AddNum {
    public static void main(String[] args) {
    }
    public static ArrayList get(int[] array,int k) {
        if(array.length == 0){
            return new ArrayList();
        }
        int flag = Integer.MAX_VALUE;
        int index = 0;
        ArrayList