二叉搜索树的实现，反转，遍历 -- 自我记录

二叉搜索树（BST）是一种特殊类型的二叉树，它具有以下特性：

• 节点中的值与它的左子树中的所有值都比它小。
• 节点中的值与其右子树中的所有值都比它大。
• 左子树和右子树都是二叉搜索树。

二叉搜索树的实现

我们可以使用下面的代码来实现一个二叉搜索树：

class Node {
    int data;
    Node left;
    Node right;

    public Node(int data) {
        this.data = data;
    }
}

class BinarySearchTree {
    Node root;

    public BinarySearchTree() {
        root = null;
    }

    public void insert(int data) {
        Node newNode = new Node(data);
        if (root == null) {
            root = newNode;
        } else {
            insertNode(newNode, root);
        }
    }

    private void insertNode(Node newNode, Node currentNode) {
        if (newNode.data < currentNode.data) {
            if (currentNode.left == null) {
                currentNode.left = newNode;
            } else {
                insertNode(newNode, currentNode.left);
            }
        } else {
            if (currentNode.right == null) {
                currentNode.right = newNode;
            } else {
                insertNode(newNode, currentNode.right);
            }
        }
    }

    public void search(int data) {
        Node currentNode = root;
        while (currentNode != null) {
            if (data == currentNode.data) {
                System.out.println("Found " + data);
                return;
            } else if (data < currentNode.data) {
                currentNode = currentNode.left;
            } else {
                currentNode = currentNode.right;
            }
        }
        System.out.println("Not found " + data);
    }

    public void delete(int data) {
        root = deleteNode(root, data);
    }

    private Node deleteNode(Node currentNode, int data) {
        if (currentNode == null) {
            return null;
        }
        if (data == currentNode.data) {
            if (currentNode.left == null && currentNode.right == null) {
                return null;
            } else if (currentNode.left == null) {
                return currentNode.right;
            } else if (currentNode.right == null) {
                return currentNode.left;
            } else {
                Node successor = findSuccessor(currentNode);
                currentNode.data = successor.data;
                currentNode.right = deleteNode(currentNode.right, successor.data);
                return currentNode;
            }
        } else if (data < currentNode.data) {
            currentNode.left = deleteNode(currentNode.left, data);
        } else {
            currentNode.right = deleteNode(currentNode.right, data);
        }
        return currentNode;
    }

    private Node findSuccessor(Node currentNode) {
        Node successor = currentNode.right;
        while (successor.left != null) {
            successor = successor.left;
        }
        return successor;
    }

    public void preorderTraversal() {
        preorderTraversal(root);
    }

    private void preorderTraversal(Node currentNode) {
        if (currentNode != null) {
            System.out.print(currentNode.data + " ");
            preorderTraversal(currentNode.left);
            preorderTraversal(currentNode.right);
        }
    }

    public void inorderTraversal() {
        inorderTraversal(root);
    }

    private void inorderTraversal(Node currentNode) {
        if (currentNode != null) {
            inorderTraversal(currentNode.left);
            System.out.print(currentNode.data + " ");
            inorderTraversal(currentNode.right);
        }
    }

    public void postorderTraversal() {
        postorderTraversal(root);
    }

    private void postorderTraversal(Node currentNode) {
        if (currentNode != null) {
            postorderTraversal(currentNode.left);
            postorderTraversal(currentNode.right);
            System.out.print(currentNode.data + " ");
        }
    }

    public void levelorderTraversal() {
        Queue<Node> queue = new LinkedList<Node>();
        queue.add(root);
        while (!queue.isEmpty()) {
            Node currentNode = queue.poll();
            System.out.print(currentNode.data + " ");
            if (currentNode.left != null) {
                queue.add(currentNode.left);
            }
            if (currentNode.right != null) {
                queue.add(currentNode.right);
            }
        }
    }
}

二叉搜索树的反转

我们可以使用下面的代码来反转一个二叉搜索树：

public void reverse() {
    root = reverseNode(root);
}

private Node reverseNode(Node currentNode) {
    if (currentNode == null) {
        return null;
    }
    Node leftNode = reverseNode(currentNode.left);
    Node rightNode = reverseNode(currentNode.right);
    currentNode.left = rightNode;
    currentNode.right = leftNode;
    return currentNode;
}

二叉搜索树的前序遍历

我们可以使用下面的代码来进行二叉搜索树的前序遍历：

public void preorderTraversal() {
    preorderTraversal(root);
}

private void preorderTraversal(Node currentNode) {
    if (currentNode != null) {
        System.out.print(currentNode.data + " ");
        preorderTraversal(currentNode.left);
        preorderTraversal(currentNode.right);
    }
}

二叉搜索树的中序遍历

我们可以使用下面的代码来进行二叉搜索树的中序遍历：

public void inorderTraversal() {
    inorderTraversal(root);
}

private void inorderTraversal(Node currentNode) {
    if (currentNode != null) {
        inorderTraversal(currentNode.left);
        System.out.print(currentNode.data + " ");
        inorderTraversal(currentNode.right);
    }
}

二叉搜索树的后序遍历

我们可以使用下面的代码来进行二叉搜索树的后序遍历：

public void postorderTraversal() {
    postorderTraversal(root);
}

private void postorderTraversal(Node currentNode) {
    if (currentNode != null) {
        postorderTraversal(currentNode.left);
        postorderTraversal(currentNode.right);
        System.out.print(currentNode.data + " ");
    }
}

二叉搜索树的层序遍历

我们可以使用下面的代码来进行二叉搜索树的层序遍历：

public void levelorderTraversal() {
    Queue<Node> queue = new LinkedList<Node>();
    queue.add(root);
    while (!queue.isEmpty()) {
        Node currentNode = queue.poll();
        System.out.print(currentNode.data + " ");
        if (currentNode.left != null) {
            queue.add(currentNode.left);
        }
        if (currentNode.right != null) {
            queue.add(currentNode.right);
        }
    }
}