数据结构系列之折半查找树

                                                                                                                   折半查找树的Java实现

1、构建树的节点类

package 二叉树;

public class IntBSTNode {

	protected int key;                //数据域
	protected IntBSTNode left,right;  //左节点域和右节点域
	public IntBSTNode(){              //构造函数
		left=right=null;
	}
	public IntBSTNode(int e1){        //构造函数
		this(e1,null,null);
	}
	public IntBSTNode(int e1,IntBSTNode lt,IntBSTNode rt){//构造函数
		key=e1;
		left=lt;
		right=rt;
	}
	public void visit(){               //访问节点值
		System.out.print(key+" ");
	}
}

2、构建折半查找树类

package 二叉树;
import java.util.Stack;

import 队列.ArrayQueue;

public class IntBST {

	protected IntBSTNode root;
	public IntBST(){
		root=null;
	}

	public boolean search(IntBSTNode p,int e1){ //查找e1是否在树中，若在返回true
		while(p!=null)
			if(e1==p.key)
				return true;
			else if(e1<p.key)
				p=p.left;
			else p=p.right;
		return false;
	}
	public void breadthFirst(){           //广度优先非递归遍历
		IntBSTNode p=root;
		ArrayQueue q=new ArrayQueue(20);
		if(p!=null){
			q.enqueue(p);
			while(!q.isEmpty()){
				p=(IntBSTNode)q.dequeue();
				p.visit();
				if(p.left!=null)
					q.enqueue(p.left);
				if(p.right!=null)
					q.enqueue(p.right);
			}
		}
	}
	public void preOrder(IntBSTNode p){  //深度优先遍历之先序遍历VLR
		if(p!=null){
			p.visit();
			preOrder(p.left);
			preOrder(p.right);
		}
	}
	public void inOrder(IntBSTNode p){   //深度优先遍历之中序遍历LVR
		if(p!=null){
			inOrder(p.left);
			p.visit();
			inOrder(p.right);
		}
	}
    public void postOrder(IntBSTNode p){    //深度优先遍历之后序遍历LRV
    	if(p!=null){
    		postOrder(p.left);
    		postOrder(p.right);
    		p.visit();
    	}
	}
    public void iterativePreorder(){        //先序遍历的非递归实现
    	IntBSTNode p=root;
    	Stack  s=new Stack();
    	if(p!=null){
    		s.push(p);
    		while(!s.isEmpty()){
    			p=(IntBSTNode)s.pop();
    			p.visit();
    			if(p.right!=null)
    				s.push(p.right);
    			if(p.left!=null)
    				s.push(p.left);
    		}
    	}
    }
    public void iterativeInorder(){       //中序遍历的非递归实现
    	IntBSTNode p=root;
    	Stack  s=new Stack();
    	while(p!=null){
    		while(p!=null){
    			if(p.right!=null)
    				s.push(p.right);
    			s.push(p);
    			p=p.left;
    		}
    		p=(IntBSTNode)s.pop();
    		while(!s.isEmpty()&&p.right==null){
    			p.visit();
    			p=(IntBSTNode)s.pop();
    		}
    		p.visit();
    		if(!s.isEmpty())
    			p=(IntBSTNode)s.pop();
    		else
    			p=null;
    	}
    }
    public void iterativePostorder(){       //后序遍历的非递归实现
    	IntBSTNode p=root,q=root;
    	Stack  s=new Stack();
    	while(p!=null){
    		for(;p.left!=null;p=p.left)
    			s.push(p);
    		while(p!=null&&(p.right==null||p.right==q)){
    			p.visit();
    			q=p;
    			if(s.isEmpty())
    				return;
    			p=(IntBSTNode)s.pop();
    		}
    		s.push(p);
    		p=p.right;
    	}
    }

    public void insert(int e1){           //插入（保证是折半查找树的根源）
    	IntBSTNode p=root,prev=null;
    	while(p!=null){
    		prev=p;
    		if(p.key<e1)
    			p=p.right;
    		else
    			p=p.left;
    	}
    	if(root==null)
    		root=new IntBSTNode(e1);
    	else if(prev.key<e1)
    		prev.right=new IntBSTNode(e1);
    	else
    		prev.left=new IntBSTNode(e1);
    }
    public void deleteByMerging(int e1){       //合并删除法
    	IntBSTNode tmp,node,p=root,prev=null;
    	while(p!=null&&p.key!=e1){
    		prev=p;
    		if(p.key<e1)
    			p=p.right;
    		else
    			p=p.left;
    	}
    	node=p;
    	if(p!=null&&p.key==e1){
    		if(node.right==null)
    			node=node.left;
    		else if(node.left==null)
    			node=node.right;
    		else{
    			tmp=node.left;
    			while(tmp.right!=null)
    				tmp=tmp.right;
    			tmp.right=node.right;
    			node=node.left;
    		}
    		if(p==root)
    			root=node;
    		else if(prev.left==p)
    			prev.left=node;
    		else
    			prev.right=node;
    	}
    	else if(root!=null)
    		System.out.println("key"+e1+"is not in the tree");
    	else System.out.print("the tree is empty");
    }
}

3、构建测试类

package 二叉树;

public class Test {

	public static void main(String[] args) {
		IntBST i=new IntBST();
		i.insert(5);
		i.insert(3);
		i.insert(7);
		i.insert(1);
		i.insert(4);
		i.insert(6);
		i.insert(8);
		//广度优先遍历
		System.out.print("广度优先遍历:");
		i.breadthFirst();
		System.out.println();
		//先序遍历(迭代法和非迭代法)
		System.out.println("先序遍历:");
		i.preOrder(i.root);
		System.out.println();
		i.iterativePreorder();
		System.out.println();
		//中序遍历(迭代法和非迭代法)
		System.out.println("中序遍历:");
		i.inOrder(i.root);
		System.out.println();
		i.iterativeInorder();
		System.out.println();
		//后序遍历(迭代法和非迭代法)
		System.out.println("后序遍历:");
		i.postOrder(i.root);
		System.out.println();
		i.iterativePostorder();
		//查找
		System.out.println();
		System.out.println(i.search(i.root, 4));
		System.out.println(i.search(i.root, 2));
	}

}

树建好后的结构是这样的：

4、测试结果

广度优先遍历:5 3 7 1 4 6 8 
先序遍历:
5 3 1 4 7 6 8 
5 3 1 4 7 6 8 
中序遍历:
1 3 4 5 6 7 8 
1 3 4 5 6 7 8 
后序遍历:
1 4 3 6 8 7 5 
1 4 3 6 8 7 5 
true
false