4.3问题：

给定一个有序整数数组，元素各不相同且按升序排列，编写一个算法，创建一棵高度最小的二叉查找树。

思考：

要创建一棵高度最小的树，就必须让左右子树的节点数量越接近越好，也就是说，我们要让数组中间的值成为根结点，这么一来，数组左边一半就成为左子树，右边一半成为右子树。

运用createMinimalBST方法，递归的方式，这个方法会传入数组的一个区段，并返回最小树的根结点。

该算法的描述如下：

（1）将数组中间位置的元素插入树中。

（2）将数组左半边元素插入左子树。

（3）将数组右半边元素插入右子树。

（4）递归处理。

如下：

扫描二维码关注公众号，回复： 3799081 查看本文章

	public static Node createMinimalBST(int arr[],int start,int end){
		if(end<start){
			return null;
		}
		int mid = (start+end)/2;
		Node n = new Node(arr[mid]);
		n.leftChild = createMinimalBST(arr,start,mid - 1);
		n.rightChild = createMinimalBST(arr,mid + 1,end);
		return n;
	}
	
	public static Node createMinimalBST(int array[]){//方法重载
		return createMinimalBST(array,0,array.length - 1);
	}
	

import java.util.*;
 
class Node {
	Node leftChild;
	Node rightChild;
	int data;
	
	Node(int newData) {//构造方法
		leftChild = null;
		rightChild = null;
		data = newData;
	}
}

class BinTreeTraverse{//创建的为完全二叉树。
	public static Node createMinimalBST(int arr[],int start,int end){
		if(end<start){
			return null;
		}
		int mid = (start+end)/2;
		Node n = new Node(arr[mid]);
		n.leftChild = createMinimalBST(arr,start,mid - 1);
		n.rightChild = createMinimalBST(arr,mid + 1,end);
		return n;
	}
	
	public static Node createMinimalBST(int array[]){//方法重载
		return createMinimalBST(array,0,array.length - 1);
	}
	
	/**
	 * 先序遍历
	 */
	public static void preOrderTraverse(Node node){
		if (node == null)
			return;
		System.out.print(node.data + " ");
		preOrderTraverse(node.leftChild);
		preOrderTraverse(node.rightChild);
	}

	/**
	 * 中序遍历
	 */
	public static void inOrderTraverse(Node node) {
		if (node == null)
			return;
		inOrderTraverse(node.leftChild);
		System.out.print(node.data + " ");
		inOrderTraverse(node.rightChild);
	}

	/**
	 * 后序遍历
	 */
	public static void postOrderTraverse(Node node) {
		if (node == null)
			return;
		postOrderTraverse(node.leftChild);
		postOrderTraverse(node.rightChild);
		System.out.print(node.data + " ");
	}
}

class MinimalBST{
	public static void main(String[] args){
		int array[]=new int[9];
		for(int i=0;i<array.length;){
			array[i]=++i;
		}
		
		//建立二叉树以及遍历
		System.out.println("二叉树建立以及遍历：");
		BinTreeTraverse binTree = new BinTreeTraverse();
		Node root = binTree.createMinimalBST(array);
		
		System.out.println("先序遍历：");
		binTree.preOrderTraverse(root);
		System.out.println();
		
		System.out.println("中序遍历：");
		binTree.inOrderTraverse(root);
		System.out.println();
		
		System.out.println("后序遍历：");
		binTree.postOrderTraverse(root);
		
		System.exit(0);
	}
}