java 二叉树

package erchashu;
import java.util.Scanner;

class CBTType{
	String data;
	CBTType left;
	CBTType right;
}

public class BinaryTree{
	static final int MAXLEN = 20;
	static Scanner input = new Scanner(System.in);
	@SuppressWarnings("unused")
	CBTType InitTree(){
		CBTType rootNode;
		if((rootNode = new CBTType())!=null){
			System.out.print("input the rootNode data:\n");
			rootNode.data = input.next();
			rootNode.left = null;
			rootNode.right = null;
			if(rootNode!=null)
				return rootNode;
			else
				return null;
		}
		return null;
	}
	
	void AddTreeNode(CBTType rootNode){
		CBTType treeNode,parent;
		String data;
		int menusel;
		if((treeNode = new CBTType())!=null){
			System.out.print("input the treeNode data:\n");
			treeNode.data = input.next();
			treeNode.left = null;
			treeNode.right = null;
			System.out.print("input the parent data of treeNode:\n");
			data = input.next();
			parent = TreeFindNode(rootNode,data);
			if(parent == null){
				System.out.print("can not find the parent node:\n");
				System.out.printf("the binary tree test end!");
				treeNode = null;
				System.exit(0);
			}
			System.out.print("1.add treeNode as left-son-tree node;2.add treeNode as right-son-tree node:\n");
			do{
				menusel = input.nextInt();
				switch(menusel){
					case 1:
						if(parent.left != null)
							System.out.print("the left-son-tree node is not empty!\n");
						else
							parent.left = treeNode;
						break;
					case 2:
						if(parent.right != null)
							System.out.print("the right-son-tree node is not empty!\n");
						else
							parent.right = treeNode;
						break;
					default:
						System.out.print("invalid parameter!\n");
				}
			}while(menusel!=1 && menusel!=2);
		}
	}
	
	CBTType TreeFindNode(CBTType rootNode,String data){
		CBTType treeNode;
		if(rootNode == null)
			return null;
		else{
			if(rootNode.data.equals(data))
				return rootNode;
			else{
				if((treeNode=TreeFindNode(rootNode.left,data)) != null)
					return treeNode;
				else if((treeNode=TreeFindNode(rootNode.right,data)) != null)
						return treeNode;
					else
						return null;
			}	
		}
	}
	
	CBTType TreeLeftNode(CBTType treeNode){
		if(treeNode != null)
			return treeNode.left;
		else
			return null;
	}
	
	CBTType TreeRightNode(CBTType treeNode){
		if(treeNode != null)
			return treeNode.right;
		else
			return null;
	}
	
	int TreeIsEmpty(CBTType rootNode){
		if(rootNode != null)
			return 1;
		else
			return 0;
	}
	
	int TreeDepth(CBTType rootNode){
		int depthLeft,depthRight;
		if(rootNode == null)
			return 0;
		else{
			depthLeft = TreeDepth(rootNode.left);
			depthRight = TreeDepth(rootNode.right);
			if(depthLeft > depthRight)
				return (depthLeft + 1);
			else
				return (depthRight + 1);
		}
	}
	
	void ClearTree(CBTType rootNode){
		if(rootNode != null){
			ClearTree(rootNode.left);
			ClearTree(rootNode.right);
			rootNode = null;
		}
	}
	
	void TreeNodeData(CBTType treeNode){
		System.out.printf("%s",treeNode.data);
		System.out.printf("\t");
	}
	
	void LevelTree(CBTType rootNode){
		CBTType p;
		CBTType[]q = new CBTType[MAXLEN];
		int head = 0;
		int tail = 0;
		if(rootNode != null){
			tail = (tail+1)%MAXLEN;
			q[tail] = rootNode;
		}
		while(head != tail){
			head = (head+1)%MAXLEN;
			p = q[head];
			TreeNodeData(p);
			if(p.left != null){
				tail = (tail+1)%MAXLEN;
				q[tail] = p.left;
			}
			if(p.right != null){
				tail = (tail+1)%MAXLEN;
				q[tail] = p.right;
			}
		}
	}
	
	void DLRTree(CBTType rootNode){
		if(rootNode != null){
			TreeNodeData(rootNode);
			DLRTree(rootNode.left);
			DLRTree(rootNode.right);
		}
	}
	
	void LDRTree(CBTType rootNode){
		if(rootNode != null){
			LDRTree(rootNode.left);
			TreeNodeData(rootNode);
			LDRTree(rootNode.right);
		}
	}
	
	void LRDTree(CBTType rootNode){
		if(rootNode != null){
			LRDTree(rootNode.left);
			LRDTree(rootNode.right);
			TreeNodeData(rootNode);
		}
	}
	
	public static void main(String[] args){
		CBTType rootNode = null;
		int menusel;
		BinaryTree tree = new BinaryTree();
		rootNode = tree.InitTree();
		
		do{
			System.out.print("select menu to add treeNode:\n");
			System.out.printf("0.exit\t");
			System.out.printf("1.add treeNode\n");
			menusel = input.nextInt();
			switch(menusel){
				case 1:
					tree.AddTreeNode(rootNode);
					break;
				case 2:
					break;
				default:
					;
			}		
		}while(menusel != 0);
		
		do{
			System.out.print("select menu to traverse binary tree,0 represent to exit:\n");
			System.out.print("1.traverse by DLR\t");
			System.out.print("2.traverse by LDR\t");
			System.out.print("3.traverse by LRD\t");
			System.out.print("4.traverse by level\n");
			menusel = input.nextInt();
			switch(menusel){
				case 0:
					break;
				case 1:
					System.out.print("the result of traversing by DLR:");
					tree.DLRTree(rootNode);
					System.out.print("\n");
					break;
				case 2:
					System.out.print("the result of traversing by LDR:");
					tree.LDRTree(rootNode);
					System.out.print("\n");
					break;
				case 3:
					System.out.print("the result of traversing by LRD:");
					tree.LRDTree(rootNode);
					System.out.print("\n");
					break;
				case 4:
					System.out.print("the result of traversing by level:");
					tree.LevelTree(rootNode);
					System.out.print("\n");
					break;
				default:
					;
			}
		}while(menusel != 0);
		System.out.printf("the depth of the binary tree is:%d\n",tree.TreeDepth(rootNode));
		tree.ClearTree(rootNode);
		rootNode = null;
		System.out.printf("the binary tree test end!");
	}
}