add BST

Author: hackfengJam

BST/src/BST.java

@@ -0,0 +1,290 @@
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Stack;
+
+public class BST<E extends Comparable<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 BST() {
+        root = null;
+        size = 0;
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    // 向二分搜索树中添加新的元素e
+    public void add(E e) {
+        root = add(root, e);
+    }
+
+    // 向以node为根的二分搜索树中插入元素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;
+    }
+
+    // 查看二分搜索树种是否包含元素e
+    private 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 true;
+        else if (e.compareTo(node.e) < 0)
+            return contains(node.left, e);
+        else// e.compareTo(node.e) > 0
+            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 inOrder() {
+        inOrder(root);
+    }
+
+    private void inOrder(Node node) {
+        if (node == null)
+            return;
+
+        preOrder(node.left);
+        System.out.println(node.e);
+        preOrder(node.right);
+    }
+
+    // 二分搜索树的后序遍历
+    public void postOrder() {
+        postOrder(root);
+    }
+
+    private void postOrder(Node node) {
+        if (node == null)
+            return;
+
+        preOrder(node.left);
+        preOrder(node.right);
+        System.out.println(node.e);
+    }
+
+
+    // 二分搜索树的非递归前序遍历
+    public void preOrderNR() {
+        Stack<Node> 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 void levelOrder() {
+        Queue<Node> q = new LinkedList<>();
+        ((LinkedList<Node>) q).add(root);
+        while (!q.isEmpty()) {
+            Node cur = q.remove();
+            System.out.println(cur.e);
+
+            if (cur.right != null) {
+                ((LinkedList<Node>) q).add(cur.right);
+
+            }
+            if (cur.left != null) {
+                ((LinkedList<Node>) q).add(cur.left);
+
+            }
+        }
+    }
+
+    // 寻找二分搜索树的最小元素
+    public E minmum() {
+        if (size == 0)
+            throw new IllegalArgumentException("BST is empty!");
+
+        return minmum(root).e;
+    }
+
+    private Node minmum(Node node) {
+        if (node.left == null)
+            return node;
+        return minmum(node);
+    }
+
+    // 寻找二分搜索树的最大元素
+    public E maxmum() {
+        if (size == 0)
+            throw new IllegalArgumentException("BST is empty!");
+
+        return maxmum(root).e;
+    }
+
+    private Node maxmum(Node node) {
+        if (node.right == null)
+            return node;
+        return maxmum(node);
+    }
+
+    // 删除二分搜索树的最小元素所在节点，返回最小值
+    public E removeMin() {
+        E ret = minmum();
+        root = removeMin(root);
+        return ret;
+    }
+
+    // 删除以node为根的二分搜索树中的最小节点
+    // 返回删除节点后新的二分搜索树的根
+    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 = maxmum();
+        root = removeMax(root);
+        return ret;
+    }
+
+    public Node removeMax(Node node) {
+        if (node.right == null) {
+            Node nodeLeft = node.left;
+            node.left = null;
+            return nodeLeft;
+        }
+
+        node.right = removeMax(node.right);
+        return node;
+    }
+
+    // 从二分搜索树中删除元素为e的节点
+    public void remove(E e) {
+        root = remove(root, e);
+    }
+
+    private Node remove(Node node, 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 { // e.equals(node.e)
+
+            // 待删除节点左子树为空
+            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 = minmum(node.right);
+            successor.right = removeMin(node.right);
+            successor.left = node.left;
+
+            node.left = node.right = null;
+
+            return successor;
+        }
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder res = new StringBuilder();
+        generateBSTString(root, 0, res);
+        return res.toString();
+    }
+
+    private void generateBSTString(Node node, int depth, StringBuilder res) {
+        if (node == null) {
+            res.append(generateBSTString(depth) + "null\n");
+            return;
+        }
+
+        res.append(generateBSTString(depth) + node.e + "\n");
+        generateBSTString(node.left, depth + 1, res);
+        generateBSTString(node.right, depth + 1, res);
+    }
+
+    private String generateBSTString(int depth) {
+        StringBuilder res = new StringBuilder();
+        for (int i = 0; i < depth; i++) {
+            res.append("--");
+        }
+        return res.toString();
+
+    }
+}

BST/src/Main.java

@@ -0,0 +1,21 @@
+public class Main {
+
+
+    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);
+        }
+//        bst.preOrder();
+//        System.out.println();
+//        bst.preOrderNR();
+//        System.out.println();
+//        bst.inOrder();
+//        System.out.println();
+//        bst.postOrder();
+//        System.out.println();
+//        System.out.println(bst);
+        bst.levelOrder();
+    }
+}