JAVA实现二叉树结构

• 二叉树结构，除了根节点没有父亲，可能存在左孩子和右孩子节点。

 
 
public class TreeNode<T> {
	// 树的节点对象
	private int index;
	private T data;
	TreeNode<T> leftChild;// 左孩子节点
	TreeNode<T> rightChild;// 右孩子节点
	public TreeNode(T t) {
		this.data = t;
	}
	
	public TreeNode(int index, T t) {
		this.index = index;
		this.data = t;
	}
	public TreeNode(int index,T t,TreeNode<T> leftChild,TreeNode<T> rightChild){
		this.index = index;
		this.data = t;
		this.leftChild = leftChild;
		this.rightChild = rightChild;
	}
	public int getIndex() {
		return index;
	}
	public void setIndex(int index) {
		this.index = index;
	}
	public T getData() {
		return data;
	}
	public void setData(T data) {
		this.data = data;
	}
	public TreeNode<T> getLeftChild() {
		return leftChild;
	}
	public void setLeftChild(TreeNode<T> leftChild) {
		this.leftChild = leftChild;
	}
	public TreeNode<T> getRightChild() {
		return rightChild;
	}
	public void setRightChild(TreeNode<T> rightChild) {
		this.rightChild = rightChild;
	}
}

    /**
 
 
 * 代码实现树结构：树的创建，树的深度，树的节点树，树的排序（前序，中序，后序），栈的方式实现树的前序遍历
 * 
 * @author timmy1
 *
 */
public class MyTree<T> {
	private TreeNode<String> root;// 根节点
	public MyTree() {
		// root = new TreeNode<String>(0, "A");
	}
	// ----------------A
	// ----------B---------C
	// ------D------E----－-----F
	// 创建二叉树 前序遍历：ABDECF 中序遍历：DBEACF
	public void createTree() {
		TreeNode<String> nodeB = new TreeNode<String>(1, "B");
		TreeNode<String> nodeC = new TreeNode<String>(2, "C");
		TreeNode<String> nodeD = new TreeNode<String>(3, "D");
		TreeNode<String> nodeE = new TreeNode<String>(4, "E");
		TreeNode<String> nodeF = new TreeNode<String>(5, "F");
		root.leftChild = nodeB;
		root.rightChild = nodeC;
		nodeB.leftChild = nodeD;
		nodeB.rightChild = nodeE;
		nodeC.rightChild = nodeF;
	}
	/**
	 * 获取树的深度
	 * 
	 * @return
	 */
	public int getTreeHeight() {
		return getTreeHeight(root);
	}
	private int getTreeHeight(TreeNode<String> node) {
		if (node == null) {
			return 0;
		} else {
			int i = getTreeHeight(node.leftChild);
			int j = getTreeHeight(node.rightChild);
			return 1 + (i > j ? i : j);
		}
	}
	/**
	 * 获取树的节点个数
	 * 
	 * @return
	 */
	public int getTreeSize() {
		return getTreeSize(root);
	}
	private int getTreeSize(TreeNode<String> node) {
		if (node == null) {
			return 0;
		} else {
			return 1 + getTreeSize(node.leftChild) + getTreeSize(node.rightChild);
		}
	}
	private void preTraversal() {
		TreeUtil.preTraversal(root);
	}
	/**
	 * 使用栈的方式实现前序遍历
	 */
	public void preByStack() {
		MyStack<TreeNode<String>> stack = new MyStack<>();
		stack.push(root);
		while (stack.size() != 0) {
			TreeNode<String> node = stack.peek();
			PrintUtil.print("traversal stack:" + node.getData());
			// 出栈
			stack.pop();
			// 右孩子先入栈－－》左孩子入栈
			if (node.rightChild != null) {
				stack.push(node.rightChild);
			}
			if (node.leftChild != null) {
				stack.push(node.leftChild);
			}
		}
	}
	/**
	 * 使用栈的方式实现中序遍历
	 */
	public void midByStack() {
		MyStack<TreeNode<String>> stack = new MyStack<>();
		stack.push(root);
		while (stack.size() != 0) {
			TreeNode<String> node = stack.peek();
			// 全部左边的节点保存后取出来
			while (node.leftChild != null) {
				node = node.leftChild;
				stack.push(node);
			}
			// 左边孩子节点出栈
			if (stack.size() > 1) {// 说明有左孩子，左边孩子节点往外面出栈
				PrintUtil.print("traversal stack:" + stack.peek().getData());
				stack.pop();
			}
			// 中间节点出栈
			TreeNode<String> midNode = stack.peek();
			if (midNode != null) {
				PrintUtil.print("traversal stack:" + midNode.getData());
				stack.pop();
			}
			// 右边孩子入栈
			if (midNode != null && midNode.rightChild != null)
				stack.push(midNode.rightChild);
		}
	}
	// ----------------A
	// ----------B---------C
	// ------D------E----#-----F
	// ---#----#---#--#------#---#
	// ABD##E##C#F##
	//
	/**
	 * 根据已经前序遍历好的字符串list，创建二叉树
	 */
	public TreeNode<String> createBinaryTreeByPreTraversal(List<String> list) {
		if (list.size() == 0)
			return null;
		String data = list.get(0);
		if (data.equals("#")) {
			list.remove(0);
			return null;
		}
		TreeNode<String> node = new TreeNode<String>(list.size(), data);
		if (root == null) {
			root = node;
		}
		list.remove(0);
		node.leftChild = createBinaryTreeByPreTraversal(list);
		node.rightChild = createBinaryTreeByPreTraversal(list);
		return node;
	}
	public static void main(String[] args) {
		MyTree<String> tree = new MyTree<>();
		// tree.createTree();
		// int height = tree.getTreeHeight();
		// PrintUtil.print("tree height:" + height);
		// PrintUtil.print("tree size:" + tree.getTreeSize());
		// // tree.preTraversal();
		// tree.midByStack();
		String str = "ABD##E##C#F##";
		char[] charArr = str.toCharArray();
		List<String> data = new ArrayList<String>();
		for (char c : charArr) {
			data.add(c + "");
		}
		tree.createBinaryTreeByPreTraversal(data);
		tree.preTraversal();
	}
}

  
  
public class TreeUtil {
	/**
	 * 迭代方式，前序遍历树节点
	 * 
	 * @param node
	 */
	public static void preTraversal(TreeNode<?> node) {
		if (node == null) {
			return;
		}
		PrintUtil.print("pre Traversal:" + node.getData());
		preTraversal(node.leftChild);
		preTraversal(node.rightChild);
	}
	public static void midTraversal(TreeNode<?> node) {
		if (node == null) {
			return;
		}
		midTraversal(node.leftChild);
		PrintUtil.print("pre Traversal:" + node.getData());
		midTraversal(node.rightChild);
	}
	public static void nextTraversal(TreeNode<?> node) {
		if (node == null) {
			return;
		}
		midTraversal(node.leftChild);
		midTraversal(node.rightChild);
		PrintUtil.print("pre Traversal:" + node.getData());
	}
}