本身是二叉树，每个节点大于其左子树的所有结点的值，小于其右子树的所有结点的值。子树也是一棵二分搜索树。树中的元素具有可比性，不包括重复元素。 中序自带排序。
代码
public class BinarySearchTree<E extends Comparable<E>> implements Iterable<E>{
//二分搜索树结点的定义
private class Node{
public E e;
public Node left,right;
public Node(E e){
this.e=e;
left=null;
right=null;
}
}
private Node root;//根结点的指针
private int size;//结点的个数
//创建一棵空的二分搜索树
public BinarySearchTree(){
root = null;
size=0;
}
//获取二分搜索树的元素个数
public int size(){
return size;
}
//判断二分搜索树是否为空
public boolean isEmpty(){
return size==0 && root==null;
}
//向二分搜索树中添加一个元素e
public void add (E e){
root=add(root,e);
}
//向以node为根的二分搜索树中添加元素e。并返回新节点插入之后的二分搜索树的根
private void add(Node node,E e){
if(node==null){
size++;
return new Node(e);
}
if(e.compareTo(node.e)<0){
node.left=add(node.left,e);
}else if(e.compareTo(node.e)>0){
node.right=add(node.right,e);
}
return node;
}
//判断二分搜索树中是否包含元素e
public boolean contains(E e){
return contains(root,e);
}
//以node为根节点的树中，判断e是否存在
private boolean contains(Node node,E e){
if(node==null){
return false;
}
if(e.compareTo(node.e)==0){
return ture;
}
if(e.compareTo(node.e)<0){
return contains(node.left,e);
}else{
return contains(node.right,e);
}
}
//前序遍历
public void preOrder(){
preOrder(root);
}
//前序遍历的递归实现
private void preOrder(Node node){
if(node==null){
return;
}
System.out.println(node.e);
preOrder(node.left);
preOrder(node.right);
}
//前序遍历的非递归实现
public void preOrderNR(){
LinkedList<Node> stack = new LinkedList<>();
stack.push(root);
while(!static.isEmpty()){
Node cur= stack.pop();
System.out.println(cur.e);
if(cur.right!=null){
stack.push(cur.right);
}
if(cur.left!=null){
stack.push(cur.left);
}
}
}
//中序遍历
public void inOrder(){
inOrder(root);
}
//中序遍历的递归实现
private void inOrder(Node node){
if(node==null){
return;
}
inOrder(node.left);
System.out.println(node.e);
inOrder(node.right);
}
//中序遍历的非递归实现
public void inOrderNR(){
LinkedList<Node> stack = new LinkedList<>();
Node p =root;
while(p!=null){
stack.push(p);
p=p.left;
}
while(!static.isEmpty()){
Node cur= stack.pop();
System.out.println(cur.e);
if(cur.right!=null){
p=cur.right;
while(p!=null){
stack.push(p);
p=p.left;
}
}
}
}
//后序遍历
public void postOrder(){
postOrder(root);
}
//后序遍历的递归实现
private void postOrder(Node node){
if(node==null){
return;
}
postOrder(node.left);
postOrder(node.right);
System.out.println(node.e);
}
//层序遍历
public void levelOrder(){
LinkedList<Node> queue = new LinkedList<>();
queue.offer(root);
while(!queue.isEmpty()){
Node cur=queue.poll();
System.out.println(cur.e);
if(cur.left != null){
queue.offer(cur.left);
}
if(cur.right!=null){
queue.offer(cur.right);
}
}
}
//返回二分搜索树中的最小值
public E minnum(){//迭代
if(isEmpty()){
throw new IllegalArgumentException("BST IS EMPTY");
}
Node p = root;
while(p.left!=null){
p=p.left;
}
return p.e;
}
public E minnum(){//递归
if(isEmpty()){
throw new IllegalArgumentException("BST IS EMPTY");
}
return minnum(root).e;//返回的是结点
}
private Node minnum(Node node){//返回以Node为根结点的二分搜索树中最小值的结点
if(node.left==null){
return node;
}
return minnum(node.left);
}
public E maxnum(){//迭代
if(isEmpty()){
throw new IllegalArgumentException("BST IS EMPTY");
}
return maxnum(root).e;
}
private Node minnum(Node node){
if(node.right==null){
return node;
}
return maxnum(node.right);
}
//删除最小值
public E removeMin(){
E ret = minnum();
root = removeMin(root);
return ret;
}
private Node removeMin(Node node){//删除最小值并返回新树的根
if(node.left==null){
Node rightNode=node.right;
node.right=null;
size--;
return rightNode;
}
node.left=removeMin(node.left);
return node;
}
//删除最大值
public E removeMax(){
E ret = maxnnum();
root = removeMax(root);
return ret;
}
private Node removeMax(Node node){//删除最大值并返回新树的根
if(node.right==null){
Node leftNode=node.left;
node.left=null;
size--;
return leftNode;
}
node.right=removeMax(node.right);
return node;
}
//删除二分搜索树中任意元素e
public void remove(E e){//递归
root=remove(root,e);
}
private Node remove(Node node,E e){//删除e的结点并返回新树的根
if(node ==null){
return null;
}
if(e.compareTo(node.e)<0){
node.left=remove(node.left,e);
return node;
}else if(e.compareTo(node.e)<0){
node.right=remove(node.right,e);
return node;
}else{
//如果左子树为空
if(node.left==null){
Node rightNode=node.right;
node.right=null;
size--;
return rightNode;
}
//如果右子树为空
if(node.right==null){
Node leftNode=node.left;
node.left=null;
size--;
return leftNode;
}
//如果右，左子树都不为空
Node successor = minnum(node.right);
successor.right=removeMin(node.right);
successor.left=node.left;
node.left=node.right=null;
return successor;
}
}
//删除方法2
@Override
public String toString(){
if(isEmpty()){
return "[]";
}
StringBuilder sb = new StringBuilder();
//中序
inOrderByString(root,sb);
return sb.toString();
}
private void inOrderByString(Node node,StringBuilder sb){
if(node==null){
return;
}
inOrderByString(node.left,sb);
sb.append(node.e+" ");
inOrderByString(node.right,sb);
}
@Override
public Iterator<E> iterator(){
return null;
}
private class BSTInterator implements Iterator<E>{
@Override
public boolean hasNext(){
return false;
}
@Override
public E next(){
return null;
}
}
}
//测试
import BinarySearch;
public class TestBST{
public static void main(String[] args){
BinarySearchTree<Integer> tree=new BinarySearchTree<>();
tree.add(4);
tree.add(3);
tree.add(5);
tree.add(2);
tree.add(6);
tree.add(1);
System.out.println(tree.contains(6));
System.out.println(tree.contains(8));
tree.preOrder();
tree.inOrder();
tree.preOrderNR();
tree.inOrderNR();
tree.levelOrder();
System.out.println("min"+tree.minnum());
System.out.println(tree.removeMin());
System.out.println("min"+tree.minnum());
System.out.println(tree.removeMax());
tree.inOrderNR();
remove(3);
}
}
