9일째 두 갈래 나무 재건

/**
 *  6 
 */
public class ConstructBinaryTree<T> {

	private int mIndex = 0;
	
	private Node<T> mRootNode;
	
	
	public boolean create(T[] beforeData, T[] afterData) {
		if (beforeData == null || afterData == null 
				|| beforeData.length <= 0 
				|| afterData.length <= 0
				|| afterData.length != beforeData.length) {
			return false;
		}
		
		mIndex = 0;
		
		mRootNode = createTree(beforeData, afterData, 0, beforeData.length - 1);
		
		return true;
	}
	
	public Node<T> createTree(T[] beforeData, T[] afterData, int start, int end) {
		int length = beforeData.length;
		
		T value = beforeData[mIndex];
		int dataIndex = getValueIndex(value, afterData);
		
		Node<T> node = new Node<T>(value);
		
		int beforeIndex = mIndex + 1;
		if (beforeIndex < length) {
			T leftValue = beforeData[beforeIndex];
			int leftIndex = getValueIndex(leftValue, afterData);
			if (leftIndex >= start && leftIndex <= end && leftIndex < dataIndex) {
				mIndex++;
				node.setLeftNode( createTree(beforeData, afterData, start, dataIndex-1) );
			}
		}
		
		int afterIndex = mIndex + 1;
		if (afterIndex < length) {
			T rightValue = beforeData[afterIndex];
			int rightIndex = getValueIndex(rightValue, afterData);
			if (rightIndex >= start && rightIndex <= end && rightIndex > dataIndex) {
				mIndex++;
				node.setRightNode( createTree(beforeData, afterData, dataIndex+1, end) );
			}
		}
		
		
		return node;
	}
	
	public int getValueIndex(T data, T[] afterData) {
		
		for (int i = 0; i < afterData.length; i++) {
			T value = afterData[i];
			if (value == data) {
				return i;
			}
		}
		
		return -1;
	}
	
	public Node<T> getRootNode() {
		return mRootNode;
	}
	
	/**
	 *  ， 
	 * 
	 * @param data
	 */
	public void create(T[] data) {
		if (data == null || data.length <= 0) {
			return;
		}
		
		System.err.println(" ");
		mIndex = 0;
		mRootNode = createNode(data);
		System.out.println("
  value = " + mRootNode.getData());
	}
	
	
	public Node<T> createNode(T[] data) {
		if (mIndex >= data.length) {
			return null;
		}
		
		Node<T> node = null;
		
		T value = data[mIndex++];
		if (value != null) {
			node = new Node<T>(value);
			
			System.out.print(value + "  ");
			
			node.setLeftNode(createNode(data));
			node.setRightNode(createNode(data));
		}
		
		
		return node;
	}
	
	
	/**
	 *  
	 * 
	 * @param node
	 */
	public void left(Node<T> node) {
		if (node != null) {
			System.out.print(node.getData() + "  ");
			left(node.getLeftNode());
			left(node.getRightNode());
		}
	}

	
	private class Node<T> {
		private T mData;
		private Node<T> mLeftNode;
		private Node<T> mRightNode;
		
		public Node(T data) {
			mData = data;
		}
		
		public Node(T data, Node<T> leftNode, Node<T> rightNode) {
			mData = data;
			mLeftNode = leftNode;
			mRightNode = rightNode;
		}
		
		public void setData(T data) {
			mData = data;
		}
		
		public void setLeftNode(Node<T> node) {
			mLeftNode = node;
		}
		
		public void setRightNode(Node<T> node) {
			mRightNode = node;
		}
		
		public T getData() {
			return mData;
		}
		
		public Node<T> getLeftNode() {
			return mLeftNode;
		}
		
		public Node<T> getRightNode() {
			return mRightNode;
		}
	}
	
	
	public static void main(String[] args) {
		Integer[] left = {1, 2, 4, 7, 3, 5, 6, 8};
		Integer[] middle = {4, 7, 2, 1, 5, 3, 8, 6};
		ConstructBinaryTree<Integer> binaryTree = new ConstructBinaryTree<Integer>();
		binaryTree.create(left, middle);
		
		binaryTree.left(binaryTree.getRootNode());
		
	}

	
}