Java-数据结构-泛型BST-CPT102-tutorial Week6

也就两个部分：

Node:

package models.BST;

public class BSTNode<E extends Comparable<E>> {
    E data;
    BSTNode<E> leftChild, rightChild;

    public BSTNode() {
    }

    public BSTNode(E data, BSTNode<E> leftChild, BSTNode<E> rightChild) {
        this.data = data;
        this.leftChild = leftChild;
        this.rightChild = rightChild;
    }

    public BSTNode(E data) {
        this.data = data;
        this.leftChild = null;
        this.rightChild = null;
    }

    public String toString() {
        return "This BSTNode is [" + data + "]";
    }

    public E getLeftmostData() {
        if (leftChild == null) return data;
        else return leftChild.getLeftmostData();
    }

    public E getRightmostData() {
        if (rightChild == null) return data;
        else return rightChild.getRightmostData();
    }

    public String inorderPrint() {
        String res = "";
        if (leftChild != null) res += leftChild.inorderPrint() + " ";
        res += data + " ";
        if (rightChild != null) res += rightChild.inorderPrint() + " ";
        return res.substring(0, res.length() - 1);
    }

    public String preorderPrint() {
        String res = data + " ";
        if (leftChild != null) res += leftChild.preorderPrint() + " ";
        if (rightChild != null) res += rightChild.preorderPrint() + " ";
        return res.substring(0, res.length() - 1);
    }

    public String postorderPrint() {
        String res = "";
        if (leftChild != null) res += leftChild.preorderPrint() + " ";
        if (rightChild != null) res += rightChild.preorderPrint() + " ";
        res += data + " ";
        return res.substring(0, res.length() - 1);
    }

    public boolean isLeaf() {
        return leftChild == null && rightChild == null;
    }

    public BSTNode<E> removeLeftmost() {
        if (leftChild == null) return rightChild;
        else {
            leftChild = leftChild.removeLeftmost();
            return this;
        }
    }

    public BSTNode<E> removeRightmost() {
        if (rightChild == null) return leftChild;
        else {
            rightChild = rightChild.removeLeftmost();
            return this;
        }
    }

    public int Size(BSTNode<E> root) {
        if (root == null) return 0;
        else return 1 + Size(root.leftChild) + Size(root.rightChild);
    }
}

BST:

package models.BST;

public class BST<E extends Comparable<E>> {
    BSTNode<E> root;

    public BST() {
        root = null;
    }

    public boolean isEmpty() {
        return root == null;
    }

    public void insert(E data) {
        root = insert(root, data);
    }

    public BSTNode<E> insert(BSTNode<E> node, E data) {
        if (node == null) {
            node = new BSTNode<E>(data);
            return node;
        }
        if (data.compareTo(node.data) < 0) node.leftChild = insert(node.leftChild, data);
        else node.rightChild = insert(node.rightChild, data);
        return node;
    }

    public int countNodes() {
        return countNodes(root);
    }

    private int countNodes(BSTNode<E> root) {
        return root.Size(root); }

    public boolean search(E data) {
        return search(root, data);
    }

    private boolean search(BSTNode<E> node, E data) {
        if (node == null) return false;
        if (node.data.compareTo(data) == 0) return true;
        return node.data.compareTo(data) > 0 ? search(node.leftChild, data) : search(node.rightChild, data);
    }

    public BSTNode<E> delete(E data) {
        return delete(root, data);
    }

    private BSTNode<E> delete(BSTNode<E> node, E data) {
        if (node == null) return null;
        if (data.compareTo(node.data) < 0) node.leftChild = delete(node.leftChild, data);
        else if (data.compareTo(node.data) > 0) node.rightChild = delete(node.rightChild, data);
        else {
            if (node.leftChild == null) return node.rightChild;
            else if (node.rightChild == null) return node.leftChild;
            node.data = node.rightChild.getLeftmostData();
            node.rightChild = delete(node.rightChild, node.data);
        }
        return node;
    }

    public String inorder() {
        return "Inorder DFS of this BST is: [" + root.inorderPrint() + "]";
    }

    public String preorder() {
        return "Preorder DFS of this BST is: [" + root.preorderPrint() + "]";
    }

    public String postorder() {
        return "Postorder DFS of this BST is: [" + root.postorderPrint() + "]";
    }

}