Java 构建二叉查找树

代码参考 --《Java语言程序设计（进阶篇） 第八版》--chapter 二叉查找树

1 构建树节点

public class TreeNode {
	int value;
	TreeNode left;
	TreeNode right;
	public TreeNode(int element) {
		// TODO Auto-generated constructor stub
		value=element;
	}
	
	}

2 构建二叉树结构和基本函数

函数列表：

实现代码：

import java.util.ArrayList;

public class MyTree {
	TreeNode root;
	int size=0;
	public MyTree(){
		
	}
	//将数组中元素添加到树节点
	public MyTree(int[] array){
		for(int i=0;i<array.length;i++)
			insert(array[i]);
	}
	public boolean insert(int element){
		//不允许插入相等的数值
		if(root==null)
		{
			root=new TreeNode(element);
		}
		else
		{
			TreeNode parent=null;
			TreeNode current=root;
			while(current!=null)
			if(element<current.value)
			{
				parent=current;
				current=current.left;
			}
			else if(element>current.value){
				parent=current;
				current=current.right;	
			}
			else {
				return false;
			}
				if(element<parent.value)
					parent.left=new TreeNode(element);
				else
					parent.right=new TreeNode(element);
				
			
		}
		size++;
		return true;
	}
	public boolean search(int element){
		if(root==null) return false;
		else{
			//TreeNode parent=null;
			TreeNode current=root;
			while(current!=null){
				if(element>current.value)
					{
					//parent=current;
					current=current.right;
					}
				else if(element<current.value){
					//parent=current;
					current=current.left;
				}
				else {
					return true;
				}
					}
			
		}
		return false;
		
	}
    public void inorder(TreeNode tRoot){
    	TreeNode current=tRoot;
    	if(current==null)
    		return;	
    	else{
    			inorder(current.left);
    			System.out.print(current.value+" ");
    			inorder(current.right);  
    	}
    	
    }
    public void preorder(TreeNode tRoot){
    	TreeNode current=tRoot;
    	if(tRoot==null)
    		return;
    	System.out.print(current.value+" ");
    	preorder(current.left);
		
		preorder(current.right);
    	}
    	
    public void postorder (TreeNode tRoot) {
    	TreeNode current=tRoot;
    	if(current==null)
    		return;
    	else{
    			postorder(current.left);
    			
    			postorder(current.right);
    			System.out.print(current.value+" ");
    		}
    		
    	}
		
	
    public ArrayList<TreeNode> path (int element){
    	//返回从根节点到该节点的路径
    	ArrayList<TreeNode> arrayList=new ArrayList<TreeNode>();
    	TreeNode current=root;
    	if(current==null)
    		return null;
    	else{
    		while(current!=null){
    			if(element==current.value)
    				{
    				//arrayList.add(current);
    				break;
    				}
    			else if(element>current.value){
    				arrayList.add(current);
    				current=current.right;
    			}
    			else{
    				arrayList.add(current);
    				current=current.left;
    				
    			}
    			
    		}
    		
    	}
		return arrayList;
    	
    	
    }

    public boolean deleNode(int element){
    	TreeNode parent=null;
    	TreeNode current=root;
    	while(current!=null){
    		if(element<current.value)
    		{
    			parent=current;
    			current=current.left;
    		}
    		else if(element>current.value)
        		{
        			parent=current;
        			current=current.right;
        		}
    		else break;
    	
    	}
    	//查不到该节点时候，(或者树为空时候)直接返回false
    	if(current==null)
    		return false;
    	//case1:当删除节点的左子树为空时候	
    	if(current.left==null){
    		if(parent==null)
    			root=current.right;
    		else {
    			if(element<parent.value)
    				parent.left=current.right;
    			if(element>parent.value)
    				parent.right=current.right;
    			
    		}
    	}
    	//case2:删除节点存在左子树；
    	else{
    		TreeNode rightMost_father=current;
    		TreeNode rightMost=current.left;
    		//rightmost 是current节点左子树中最大的右节点，且该节点没有右子数了
    		while(rightMost.right!=null)
    			{
    			  rightMost_father=rightMost;
    			  rightMost=rightMost.right;
    			}
    		current.value=rightMost.value;
    		if(rightMost_father.right==rightMost)
    		rightMost_father.right=rightMost.left;
    		else
    			rightMost_father.left=rightMost.left;
    		
    				
    		
    	}
    		
   size--; 	
    	
		return true;
    	
    }

}

3 测试函数

package offerExam;

import java.util.ArrayList;

public class TestTree {
	//测试函数一定要写main 函数呀  ！！！
	public static void main(String[] args){
		MyTree tree=new MyTree();
		tree.insert(60);
		tree.insert(55);
		tree.insert(100);
		tree.insert(45);
		tree.insert(57);
		tree.insert(67);
		tree.insert(107);
		tree.insert(59);
		tree.insert(101);
		//测试遍历函数
		System.out.println("测试遍历1：");
		System.out.println(" inorder:");
		tree.inorder(tree.root);
		System.out.println("\n preOrder:");
		tree.preorder(tree.root);
		System.out.println("\n postorder:");
		tree.postorder(tree.root);
		System.out.println();
		//测试查找函数
		int num=56;
		System.out.println(num+"  is in the tree? "+(tree.search(num)?true:false));
		//测试路径函数（path）
		int node_element=107;
		ArrayList<TreeNode> arrayList=tree.path(node_element);
		System.out.println("从根节点到 数值 "+node_element+" 路径是：");
		for(int i=0;arrayList!=null&&i<arrayList.size();i++){
			//此处对返回列表是不是为null 的判断。
			System.out.print(arrayList.get(i).value+" ");
		}
		System.out.println();
		tree.deleNode(100);
		System.out.println("测试删除树种节点100，并将结果用中序遍历");
		tree.inorder(tree.root);
		
		
		
		
		
		//测试用数组初始化树结构
		int[] array={60,55,100,45,57,67,107,59,101};
		MyTree tree2=new MyTree(array);
		System.out.println("\n 测试遍历2：");
		System.out.println(" inorder:");
		tree2.inorder(tree2.root);
		System.out.println("\n preOrder:");
		tree2.preorder(tree2.root);
		System.out.println("\n postorder:");
		tree2.postorder(tree2.root);
	
		
	}
	
	


}

运行结果

测试遍历1：
 inorder:
45 55 57 59 60 67 100 101 107 
 preOrder:
60 55 45 57 59 100 67 107 101 
 postorder:
45 59 57 55 67 101 107 100 60 
56  is in the tree? false
从根节点到 数值 107 路径是：
60 100 
测试删除树种节点100，并将结果用中序遍历
45 55 57 59 60 67 101 107 
 


测试遍历2：
 inorder:
45 55 57 59 60 67 100 101 107 
 preOrder:
60 55 45 57 59 100 67 107 101 
 postorder:
45 59 57 55 67 101 107 100 60