java二分搜索树_java——二分搜索树 BST（递归、非递归）

packageDate_pacage;importjava.util.Stack;importjava.util.ArrayList;importjava.util.LinkedList;importjava.util.Queue;importjava.util.Random;//二分搜索树

public class BST >{private classNode{publicE e;publicNode left, right;publicNode(E e) {this.e =e;

left= null;

right= null;

}

}privateNode root;private intsize;publicBST() {

root= null;

size= 0;

}public intsize() {returnsize;

}public booleanisEmpty(){return size == 0;

}//相等的元素不会重复添加

public voidadd(E e) {

root=add(root, e);

}privateNode add(Node node, E e) {if(node == null) {

size++;

node= newNode(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);

}returnnode;

}public booleancontains(E e) {returncontains(root, e);

}//搜索二分搜索树是否包含元素e

private booleancontains(Node node, E e) {if(node == null)return false;if(e.compareTo(node.e) == 0) {return true;

}else if(e.compareTo(node.e) > 0) {returncontains(node.right, e);

}else{returncontains(node.left, e);

}

}//前序遍历

public voidpreOrder() {

preOrder(root);

}private voidpreOrder(Node node) {if(node == null) {return;

}

System.out.println(node.e);

preOrder(node.left);

preOrder(node.right);

}//非递归前序遍历：栈

public voidpreOrderNR() {

Stack stack = new Stack<>();

stack.push(root);while(!stack.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 voidinOrder() {

preOrder(root);

}private voidinOrder(Node node) {if(node == null) {return;

}

inOrder(node.left);

System.out.println(node.e);

inOrder(node.right);

}//后序遍历

public voidpostOrder() {

postOrder(root);

}private voidpostOrder(Node node){if(node == null) {return;

}

postOrder(node.left);

postOrder(node.right);

System.out.println(node.e);

}//非递归 层序遍历(广度优先遍历)：队列

public voidlevelOrder() {

Queue q = new LinkedList<>();

q.add(root);while(!q.isEmpty()) {

Node cur=q.remove();

System.out.println(cur.e);if(cur.left != null) {

q.add(cur.left);

}if(cur.right != null) {

q.add(cur.right);

}

}

}//寻找二分搜索树的最小元素

publicE minimum() {if(size == 0) {throw new IllegalArgumentException("BST is empty!");

}returnminimum(root).e;

}privateNode minimum(Node node) {if(node.left == null) {returnnode;

}returnminimum(node.left);

}publicE removeMin() {

E ret=minimum();

root=removeMin(root);returnret;

}//删除掉以node为跟的二分搜索树的最小a节点//返回删除节点后的新的二分搜索树的跟

privateNode removeMin(Node node) {if(node.left == null) {

Node rightNode=node.right;

node.right= null;

size--;returnrightNode;

}

node.left=removeMin(node.left);returnnode;

}

@OverridepublicString toString() {

StringBuilder res= newStringBuilder();

generateBSTString(root,0, res);returnres.toString();

}private void generateBSTString(Node node, intdepth, StringBuilder res) {if(node == null) {

res.append(generateDepthString(depth)+ "null\n");return;

}

res.append(generateDepthString(depth)+ node.e + "\n");

generateBSTString(node.left, depth+1, res);

generateBSTString(node.right, depth+1, res);

}private String generateDepthString(intdepth) {

StringBuilder res= newStringBuilder();for(int i = 0 ; i < depth ; i ++) {

res.append("--");

}returnres.toString();

}public static voidmain(String[] args) {

BST bst = new BST<>();

Random random= newRandom();int n = 1000;for(int i = 0 ; i < n ; i ++) {//从0 到10000的一个数

bst.add(random.nextInt(10000));

}

ArrayList nums = new ArrayList<>();while( !bst.isEmpty()) {

nums.add(bst.removeMin());

}

System.out.println(nums);

}

}