package tree;
//具有可比性的泛型
public class BST<E extends Comparable> {
private class Node {
public E e;
private Node left;
private Node right;
public Node(E e) {
this.e = e;
left = null;
right = null;
}
}
private Node root;
private int size;
public BST() {
root = null;
size = 0;
}
public int size() {
return size;
}
public boolean isEmpty() {
return size == 0;
}
// 向二分搜索树中添加新的元素
// public void add(E e){
// if (root == null){
// root = new Node(e);
// size++;
// }else {
// add(root, e);
// }
// }
//向以node为根的二分搜索树中插入元素 递归算法
// private void add(Node node,E e){
// if(e.equals(node.e))
// return;
// else if (e.compareTo(node.e)<0&&node.left==null){
// node.left = new Node(e);
// size++;
// return;
// }
// else if (e.compareTo(node.e)>0&&node.right==null){
// node.right = new Node(e);
// size++;
// return;
// }
// if (e.compareTo(node.e)<0){
// add(node.left,e);
// }else
// add(node.right,e);
// }
public void add(E e) {
root = add(root, e);
}
private Node 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;
}
// 是否包含某个节点
public boolean contains(E e) {
return contains(root, e);
}
private boolean contains(Node node, E e) {
if (node==null){
return false;
}
if (e.compareTo(node.e)==0){
return true;
}else if (e.compareTo(node.e)<0){
return contains(node.left, e);
}else {
return contains(node.right, e);
}
}
//遍历
//先序遍历根左右
public void proOrder(){
preOrder(root);
}
private void preOrder(Node node){
if (node==null){
return;
}
System.out.println(node.e);
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);
inOrder(node.right);
}
//后续遍历
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);
}
@Override
public String toString() {
StringBuilder stringBuilder = new StringBuilder();
generateBSTString(root, 0, stringBuilder);
return stringBuilder.toString();
}
// 以node为根节点,深度为depth描述二叉树的字符串
private void generateBSTString(Node node,int depth,StringBuilder stringBuilder){
if (node==null){
stringBuilder.append(generateBSTString(depth) + "null\n");
return ;
}
stringBuilder.append(generateBSTString(depth) + node.e + "\n");
generateBSTString(node.left, depth + 1, stringBuilder);
generateBSTString(node.right, depth + 1, stringBuilder);
}
private String generateBSTString(int depth){
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < depth; i++) {
stringBuilder.append("--");
}
return stringBuilder.toString();
}
public static void main(String[] args) {
BST<Integer> bst = new BST<>();
int[] nums = {
5, 3, 6, 8, 4, 2};
for (int num : nums) {
bst.add(num);
}
/**
* 5
* 3 6
* 2 4 8
*
*/
// bst.proOrder();
// System.out.println();
// System.out.println(bst);
// bst.inOrder();
// System.out.println();
bst.postOrder();
System.out.println();
}
}
二分搜索树-后续遍历
猜你喜欢
转载自blog.csdn.net/weixin_45010894/article/details/108481508
今日推荐
周排行