java实现二叉树的常见操作

       树型结构是最常见的非线性结构，其中二叉树最为常见。今天我主要就是用java来实现一下树的一些常见操作。

       首先需要一个用来存储树节点值的javabean：

public class TreeBean {
	
	private int nodeValue;
	
	public int getNodeValue() {
		return nodeValue;
	}

	public void setNodeValue(int nodeValue) {
		this.nodeValue = nodeValue;
	}
}

       然后是树的节点bean：

public class TreeNode{

	private TreeBean data;
	private TreeNode leftNode;
	private TreeNode rightNode;
	
	//构造函数  
    public TreeNode(){  
        data = new TreeBean();  
    }
	
	public TreeBean getData() {
		return data;
	}

	public void setData(TreeBean data) {
		this.data = data;
	}

	public TreeNode getLeftNode() {
		return leftNode;
	}
	public void setLeftNode(TreeNode leftNode) {
		this.leftNode = leftNode;
	}
	public TreeNode getRightNode() {
		return rightNode;
	}
	public void setRightNode(TreeNode rightNode) {
		this.rightNode = rightNode;
	}

}

       最后是Tree的主体：

public class Tree {
	//树的根节点
	private TreeNode root;
	public TreeNode getRoot() {
		return root;
	}
	public void setRoot(TreeNode root) {
		this.root = root;
	}
	
	//无参构造函数
	Tree(){}
	
	Tree(int nodeValue){
		root = new TreeNode();
		TreeBean nodeBean = new TreeBean();  
        nodeBean.setNodeValue(nodeValue);
        root.setData(nodeBean);
	}
	/**
	 * 销毁树，将树置空。
	 * @author letthinking
	 * @param tree
	 * @return
	 */
	public static Tree destroy(Tree tree){
		return null;
	}
	/**
	 * 给树插入数据
	 * @author letthinking
	 * @param root
	 * @param node
	 */
	public void insert(TreeNode root,TreeNode node){
		//如果根节点为空，则赋值给根节点
		if(root == null){
			root = node;
		}else{
			//该节点与它的双亲节点比较，如果小于双亲节点，就将它作为左孩子，否则为右孩子。
			if(node.getData().getNodeValue() < root.getData().getNodeValue()){
				//判断该节点是否为空，如果不为空就继续递归。
				if(root.getLeftNode() == null){
					root.setLeftNode(node);
				}else{
					insert(root.getLeftNode(),node);
				}
			}else{
				if(root.getRightNode() == null){
					root.setRightNode(node);
				}else{
					insert(root.getRightNode(),node);
				}
			}
		}
	}
	
	/**
	 * 将树的所有节点清空
	 * @author letthinking
	 * @param root 树的根节点
	 */
	public void clearTree(TreeNode root){
		
		if(root.getData() == null){
			if(root.getLeftNode() != null){
				clearTree(root.getLeftNode());
			}
			if(root.getRightNode() != null){
				clearTree(root.getRightNode());
			}		
		}else{
			root.setData(null);
			if(root.getLeftNode() != null){
				clearTree(root.getLeftNode());
			}
			if(root.getRightNode() != null){
				clearTree(root.getRightNode());
			}	
		}
	}
	
	/**
	 * 前序遍历二叉树  
	 * @author letthinking
	 * @param root
	 * @return
	 */
	public String middleIterator(TreeNode root){
		StringBuilder str = new StringBuilder();
		//判断节点是否为空
		if(root == null){
			return str.toString();
		}else{
			//输出节点的值
			if(root.getData() != null){
				str.append(root.getData().getNodeValue()+",");
			}else{
				str.append("null,");
			}
			//递归输出左孩子的值
			str.append(middleIterator(root.getLeftNode()));
			//递归输出右孩子的值
			str.append(middleIterator(root.getRightNode()));
		}
		return str.toString();
	}
	
	/**
	 * 后序遍历二叉树  
	 * @author letthinking
	 * @param root
	 * @return
	 */
	public String afterIterator(TreeNode root){
		StringBuilder str = new StringBuilder();
		//判断节点是否为空
		if(root == null){
			return str.toString();
		}else{
			//递归输出左孩子的值
			str.append(afterIterator(root.getLeftNode()));
			//递归输出右孩子的值
			str.append(afterIterator(root.getRightNode()));
			//输出节点的值
			if(root.getData() != null){
				str.append(root.getData().getNodeValue()+",");
			}else{
				str.append("null,");
			}
		}
		return str.toString();
	}
	
	/**
	 * 求树的深度
	 * @author letthinking
	 * @param node
	 * @return
	 */
	public int treeDepth(TreeNode node){
		//定义两个变量用来存储左深度和右深度
		int leftDepth = 0;
		int rightDepth = 0;
		if(node == null){
			return 0;
		}else{
			leftDepth = treeDepth(node.getLeftNode())+1;
			rightDepth = treeDepth(node.getRightNode())+1;
		}
		//返回值最大的深度
		return leftDepth>=rightDepth?leftDepth:rightDepth;
	}
	
	public static void main(String [] args){
		
		//构造一个只有根节点的空树
		Tree tree = new Tree(35);
		//创建5个节点
		TreeNode treeNode = new TreeNode();
		treeNode.getData().setNodeValue(23);
		TreeNode treeNode1 = new TreeNode();
		treeNode1.getData().setNodeValue(56);
		TreeNode treeNode2 = new TreeNode();
		treeNode2.getData().setNodeValue(45);
		TreeNode treeNode3 = new TreeNode();
		treeNode3.getData().setNodeValue(12);
		TreeNode treeNode4 = new TreeNode();
		treeNode4.getData().setNodeValue(37);
		TreeNode treeNode5 = new TreeNode();
		treeNode5.getData().setNodeValue(19);
		//插入树中
		tree.insert(tree.root, treeNode);
		tree.insert(tree.root, treeNode1);
		tree.insert(tree.root, treeNode2);
		tree.insert(tree.root, treeNode3);
		tree.insert(tree.root, treeNode4);
		tree.insert(tree.root, treeNode5);
		//前序变量
		String result = tree.middleIterator(tree.getRoot());
		System.out.println(result);
		//后序序变量
		result = tree.afterIterator(tree.getRoot());
		System.out.println(result);
		//清空数所有节点的值
		tree.clearTree(tree.getRoot());
		result = tree.middleIterator(tree.getRoot());
		System.out.println(result);
		//得到树的深度
		System.out.println(tree.treeDepth(tree.getRoot())); 
	}
}

       可能会有地方写的不对，希望大家给指出。