4.4 使用前序遍历和中序遍历构造二叉树，并绘制树结构

代码

/**
 * 使用 前序遍历数组 和 中序遍历数组 构造一棵二叉树，并尝试绘制二叉树的树形结构
 * @author dxt
 *
 */
public class CreateTree {
	
	public static void main(String[] args) {
		//二叉树的前序遍历结果
		int[] preOrderList = {6, 3, 1, 2, 5, 9, 7};
		//二叉树的中序遍历结果
		int[] infixOrderList = {1, 2, 3, 5, 6, 7, 9};
		/*
		 * 			    6
		 * 			 /    \
		 * 			3       9
		 * 		  /   \    / 
		 * 		  1    5  7 
		 *		   \  
		 * 			2
		 */
		
		Node root = createTree(preOrderList, infixOrderList);
		//遍历验证
		System.out.println("前序遍历");
		root.preOrder();
		System.out.println("中序遍历");
		root.infixOrder();
		
		//尝试绘制
		System.out.println("尝试输出二叉树结构");
		root.preDraw(1);	//1 表示节点所在的层数，1表示根节点在第一层
	}

	/**
	 * 依据前序遍历数组 preList 和 中序遍历数组 infixList 构造一棵二叉树
	 * @param preList
	 * @param infixList
	 */
	public static Node createTree(int[] preList, int[] infixList) {
		if(preList.length != infixList.length) {
			System.out.println("程序出错啦，哈哈哈哈哈哈哈");
			return null;
		}
		//1. 判断数据是否为空
		int size = preList.length;
		if(size <= 0) {
			return null;
		}
		//2. 构造根节点
		Node root = new Node(preList[0]);
		//3. 分割数组
		//3.1 确定 preList[0] 在infixList中的索引
		int index = 0;
		while(infixList[index] != preList[0]) {
			index++;
		}
		//3.2 获取 构成root 左子树的前序列表 和 中序列表
		int[] left_infixList = new int[index];
		int[] left_preList = new int[index];
		for(int i=0; i<index; i++) {
			left_preList[i] = preList[i+1];
			left_infixList[i] = infixList[i];
		}
		
		//3.2 获取 构成root 右子树的前序列表 和 中序列表
		int right_size = size - index - 1;
		int[] right_infixList = new int[right_size];
		int[] right_preList = new int[right_size];
		for(int i=index+1; i<size; i++) {
			right_preList[i-index-1] = preList[i];
			right_infixList[i-index-1] = infixList[i];
		}
		
		//4. 递归构造root 的左子节点和右子节点
		root.left = createTree(left_preList, left_infixList);
		root.right = createTree(right_preList, right_infixList);
		
		//5. 返回根节点
		return root;
	}
}

/**
 * 节点类
 * @author dxt
 *
 */
class Node{
	int value;
	Node left;
	Node right;
	
	public Node(int value) {
		this.value = value;
		left = null;
		right = null;
	}
	
	//前序遍历
	public void preOrder() {
		System.out.println(this);
		if(this.left != null) {
			this.left.preOrder();
		}
		if(this.right != null) {
			this.right.preOrder();
		}
	}
	//中序遍历
	public void infixOrder() {
		if(this.left != null) {
			this.left.infixOrder();
		}
		System.out.println(this);
		if(this.right != null) {
			this.right.infixOrder();
		}
	}
	
	//前序遍历绘制
	public void preDraw(int level) {
		System.out.println(this.value);
		//绘制左子树
		if(this.left != null) {
			for(int i=0; i<level-1; i++) {
				System.out.print("     ");
			}
			System.out.print("+----");
			this.left.preDraw(level+1);
		}else {
			for(int i=0; i<level-1; i++) {
				System.out.print("     ");
			}
			System.out.print("+----");
			System.out.println("null");
		}
		//绘制右子树
		if(this.right != null) {
			for(int i=0; i<level-1; i++) {
				System.out.print("     ");
			}
			System.out.print("+----");
			this.right.preDraw(level+1);
		}else {
			for(int i=0; i<level-1; i++) {
				System.out.print("     ");
			}
			System.out.print("+----");
			System.out.println("null");
		}
	}
	
	@Override
	public String toString() {
		return "Node : "+value;
	}
}

结果

总结

      只尝试了代码中的那一个二叉树示例，对于别的实例可能会出现问题。若有问题还请指正，感激不尽。。。