树表查找的实现（二叉排序树）

树表查找的实现（二叉排序树）

一．实验目的
（1）熟悉二叉排序树的性质
（2）掌握二叉排序树建立与查找算法；

二．实验内容
（1）根据序列{17,25,30,33,34,45,47,50,55,90,100,120,130}画出相应的二叉排序树；

（2）在二叉树基本操作实现的代码基础上进行修改，实现二叉排序树的添加操作和查找操作
三．基于二叉排序树的查找算法设计（给出详细的算法步骤，不是程序代码）
二叉排序树的添加(add)操作：（private TreeNode add(TreeNode node,E e) ）
1）先判断root是否为空，若为空则新建结点node作为树的根返回(return new TreeNode(e)😉
2）若不为空则判断：
—如果待插入节点值（e）小于根节点的值(node.data)，将新节点插入左子树中
—如果待插入节点值（e）大于根节点的值(node.data)，将新节点插入右子树中
—节点值（e）等于根节点的值（node.data），则不需要插入

二叉排序树的查找(contains)操作：
1）先判断root是否为空，若为空则直接返回false
2）若不为空则把要查找的元素e与根节点进行比较
—如果待查找节点值（e）等于根节点的值(node.data)，直接返回true
—如果待查找节点值（e）小于根节点的值(node.data)，则继续去左边进行递归查找，若能找到则返回true，找不到则返回false
—如果待插入节点值（e）大于根节点的值(node.data)，则继续去右边进行递归查找,若能找到则返回true，找不到则返回false

二叉排序树的查找（find）操作：
1)从根开始查找，如果树为空则返回null
2)若树非空，则
—若e小于根节点的值，继续搜索左子树
—若e大于根节点的值，继续搜索右子树
—若e等于根节点的值。搜索完成，返回根节点的地址

二叉排序树的查找最小元素和最大元素
—最大元素一定在树的最右分支的端点上
—最小元素一定在树的最左分支的端点上

四．运行截图

五．源程序代码
package Tree;

import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;

public class BinarySortTree<E extends Comparable> {
private class TreeNode{
E data;
TreeNode left,right;

	public TreeNode(E e) {
		data = e;
		left = null;
		right = null;
	}
}
private TreeNode root;
private int size;

public BinarySortTree() {
	root = null;
	size = 0;
}
public int size() {
	return size;
}
public boolean isEmpty() {
	return size==0;
}
//把元素e插入到以node为根节点的子树中
public void add(E e) {
	root=add(root, e);
}
private TreeNode add(TreeNode node,E e) {
	if (node==null) {
		size++;
		return new TreeNode(e);
	}
	if (e.compareTo(node.data)<0) {
		node.left = add(node.left, e);
	}
	if (e.compareTo(node.data)>0) {
		node.right = add(node.right, e);
	}
	return node;
}

//包含关系
public boolean contains(E e) {
	return contains(root,e);
}
private boolean contains(TreeNode node,E e) {
	if (node==null) {
		return false;
	}
	if (e.equals(node.data)) {
		return true;
	}
	else if (e.compareTo(node.data)<0) {
		return contains(node.left,e);
	}
	else {
		return contains(node.right,e);
	}
}
//查找
public E find(E e) {
	return find(root, e);
}
private E find(TreeNode node,E e) {
	if (node==null) {
		return null;
	}
	if (e.equals(node.data)) {
		return node.data;
	}else if(e.compareTo(node.data)<0){
		return find(node.left, e);
	}else {
		return find(node.right, e);
	}
}
//查找最大值
public E min() {
	if (root==null) {
		return null;
	}else {
		TreeNode next = root;
		while (next.left!=null) {
			next=next.left;
		}
		return next.data;
	}
}
public E max() {
	if (root==null) {
		return null;
	}else {
		TreeNode next = root;
		while (next.right!=null) {
			next=next.right;
		}
		return next.data;
	}
}
public void preorder() {
	preorder(root);
}
//preorder为前序遍历序列
public void preorder(TreeNode t) {
	if (t==null) {
		return;
	}
	visit(t);
	preorder(t.left);
	preorder(t.right);
}
public void visit(TreeNode t) {
	System.out.println(t.data);
}
public void inorder() {
	inorder(root);
}
//inorder为中序遍历序列
private void inorder(TreeNode t) {
	if (t==null) {
		return;
	}
	inorder(t.left);
	visit(t);
	inorder(t.right);
}
public void postorder() {
	postorder(root);
}

private void postorder(TreeNode t) {
	if (t==null) {
		return;
	}
	postorder(t.left);
	postorder(t.right);
	visit(t);
}

//层序遍历
public void levelOrder(TreeNode t) {
	   if (t==null) {
		return;
	   }
	  Queue<TreeNode> queue = new LinkedList<>();
	  TreeNode curr;
	  queue.add(root);
	  while (!queue.isEmpty()) {
		curr = queue.remove();
		System.out.println(curr.data);
		if (curr.left != null) {
			queue.add(curr.left);
		}
		if (curr.right != null) {
			queue.add(curr.right);
		}
	 }
 }

public void levelOrder() {
	levelOrder(root);
}

@Override
public String toString() {
	StringBuilder res = new StringBuilder();
	generateBiTString(root,0,res);		
	return res.toString();
}

//递归方法（用的先序遍历的思想），打印以Node为根结点的子树
//depth表示Node结点在原来的二叉树中的深度，根结点深度为0
private void generateBiTString(TreeNode Node,int depth,StringBuilder res) {
if(Node==null) {
res.append(generateDepthString(depth)+“null\n”);
return;
}
//打印根结点
res.append(generateDepthString(depth)+Node.data+"\n");
//递归打印左子树
generateBiTString(Node.left,depth+1,res);
//递归打印右子树
generateBiTString(Node.right,depth+1,res);
}

//打印结点数据前表示该结点深度的字符串（–）
private String generateDepthString(int depth) {
StringBuilder res=new StringBuilder();
for(int i=0;i<depth;i++)
res.append("–");
return res.toString();
}

public static void main(String[] args) {
	BinarySortTree<Integer> bst = new BinarySortTree<>();
	int[] nums = {17,25,30,33,34,45,47,50,55,90,100,120,130};
	for (int num:nums) {
		bst.add(num);
	}
	System.out.println(bst);
	bst.inorder();
	System.out.println(bst.contains(25));
	System.out.println(bst.find(25));
	System.out.println(bst.find(1));
	System.out.println(bst.max());
	System.out.println(bst.min());
}

}