程序员代码面试指南刷题--第三章.通过有序数组生成平衡搜索二叉树

题目：
给定一个有序数组，并根据此数组生成一个平衡搜索二叉树

解法一：递归

思路： 每次取数组中间节点作为根节点

import java.io.*;
import java.util.*;
public class Main{
    public static void main(String[] args) throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] ss = br.readLine().trim().split(" ");
        int[] arr = new int[ss.length];
        for(int i=0;i<arr.length;i++) {
        	arr[i] = Integer.parseInt(ss[i]);
        }
        TreeNode root = generatTree(arr);
        showTree(root);
    }
    private static void showTree(TreeNode root) {
    	if(root==null) return;
    	show(root,0,17,"H");
	}
	private static void show(TreeNode root, int height, int len, String str) {
		if(root==null) return;
		show(root.right,height+1,len,"v");
		String realstr = str+root.val+str;
		System.out.println(space(height*len)+realstr);
		show(root.left,height+1,len,"^");
		
	}
	private static String space(int i) {
		String s = "";
		for(int j=0;j<i;j++) {
			s += " ";
		}
		return s;
	}
	private static TreeNode generatTree(int[] arr) {
    	if(arr==null) return null;
    	TreeNode r = generate(arr,0,arr.length-1);
    	return r;
	}
	private static TreeNode generate(int[] arr, int l, int r) {
		if(l>r) return null;
		int mid = (l+r)/2;
		TreeNode root = new TreeNode(arr[mid]);
		TreeNode left = generate(arr,l,mid-1);
		TreeNode right = generate(arr,mid+1,r);
		root.left = left;
		root.right = right;
		return root;
	}
	public static boolean isBalanced(TreeNode root){
        if(root==null) return true;
        boolean left = isBalanced(root.left);
        if(left==false) return false;
        boolean right = isBalanced(root.right);
        if(right==false) return false;
        TreeNode l = root.left;
        if(l!=null){
            while(l.right!=null){
                l = l.right;
            }
            if(l.val>root.val) return false;
        }
        TreeNode r = root.right;
        if(r!=null){
            while(r.left!=null){
                r = r.left;
            }
            if(r.val<root.val) return false;
        }
        return true;
    }
    public static boolean isPerfect(TreeNode root){
        if(root==null) return false;
        Queue<TreeNode> q = new LinkedList<>();
        //借助层序遍历判断
        q.offer(root);
        int presize = 1;
        int size = 0;
        boolean flag = false;
        while(!q.isEmpty()){
            while(presize-->0){
                TreeNode node = q.poll();
                if(node.left!=null){
                    if(flag=true) return false;
                    q.offer(node.left);
                    size++;
                }else{
                    flag = true;
                }
                if(node.right!=null){
                    if(flag==true) return false;
                    q.offer(node.right);
                    size++;
                }else{
                    flag = true;
                }
            }
            presize = size;
            size = 0;
            flag = false;
        }
        return true;
    }
    //递归建树
    public static TreeNode createTree(BufferedReader br){
        try{
            String[] ss = br.readLine().trim().split(" ");
            int data = Integer.parseInt(ss[0]);
            int left = Integer.parseInt(ss[1]);
            int right = Integer.parseInt(ss[2]);
            TreeNode root = new TreeNode(data);
            if(left!=0){
                root.left = createTree(br);
            }
            if(right!=0){
                root.right = createTree(br);
            }
            return root;
        }catch(Exception e){
            return null;
        }
    }
}
class TreeNode{
    int val;
    TreeNode left;
    TreeNode right;
    public TreeNode(int val){
        this.val = val;
    }
}