二分搜索树BST
递归基础实现
package com.tree;
/**
* @author 张文军
* @Description:
* @Company:南京农业大学工学院
* @version:1.0
* @date 2019/9/61:26
*/
public class BST<E extends Comparable<E>> {
private class Node {
E e;
Node left, right;
public Node(E e) {
this.e = e;
}
}
private Node root;
private int size;
public BST() {
this.root = null;
this.size = 0;
}
/**
* 添加节点
*
* @param e
*/
public void add(E e) {
root = add(root, e);
}
/**
* 递归添加节点,返回插入后的新节点
*
* @param node
* @param e
*/
private Node add(Node node, E e) {
/**
* 递归结束条件
*/
if (node == null) {
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;
}
/**
* 时候包含某个节点
*
* @param e
* @return
*/
public boolean isContain(E e) {
return isContain(root, e);
}
/**
* 递归实现是否包含一个节点
*
* @param node
* @param e
* @return
*/
private boolean isContain(Node node, E e) {
/**
* 结束条件
*/
if (node == null) {
return false;
}
if (node.e.compareTo(e) == 0) {
return true;
}
/**
* 递归
*/
if (e.compareTo(node.e) < 0) {
return isContain(node.left, e);
} else {
return isContain(node.right, e);
}
}
/**
* 前序遍历
*/
public void preOrder() {
preOrder(root);
}
private void preOrder(Node node) {
/**
* 递归终止条件
*/
if (node == null) {
return;
}
/**
* 操作
*/
System.out.println(node.e.toString());
/**
* 递归遍历
*/
preOrder(node.left);
preOrder(node.right);
}
/**
* 中序遍历
*/
public void inOrder() {
inOrder(root);
}
private void inOrder(Node node) {
/**
* 递归终止条件
*/
if (node == null) {
return;
}
/**
* 递归遍历
*/
inOrder(node.left);
/**
* 操作
*/
System.out.println(node.e.toString());
inOrder(node.right);
}
/**
* 以下代码均为测试方便而写//
*/
@Override
public String toString() {
StringBuilder builder = new StringBuilder();
generateBSTString(root, 0, builder);
return builder.toString();
}
/**
* 可视化树结构,用前序遍历的方法打印
*
* @param node 节点
* @param depth 遍历深度
* @param builder
*/
private void generateBSTString(Node node, int depth, StringBuilder builder) {
if (node == null) {
builder.append(generateBSTDepthString(depth) + "null\n");
return;
}
builder.append(generateBSTDepthString(depth) + node.e + " \n");
generateBSTString(node.left, depth + 1, builder);
generateBSTString(node.right, depth + 1, builder);
}
/**
* 打印深度
*
* @param depth
* @return
*/
private String generateBSTDepthString(int depth) {
StringBuilder builder = new StringBuilder();
for (int i = 0; i < depth; i++) {
builder.append("——>");
}
return builder.toString();
}
/**
* 测试
*
* @param args
*/
public static void main(String[] args) {
BST<Integer> bst = new BST<Integer>();
int[] ints = {9, 4, 78, 21, 5, 7};
for (int anInt : ints) {
bst.add(anInt);
}
System.out.println("前序遍历 :");
bst.preOrder();
System.out.println("后序遍历 :");
bst.inOrder();
System.out.println("--------toString :---------");
System.out.println(bst);
}
}
结果: