1232: 普通平衡树

您需要写一种数据结构（可参考题目标题），来维护一些数，其中需要提供以下操作：
1.插入一个数x；
2.删除一个数x（若有多个相同的数，只删除一个）；
3.查询x数的排名（排名定义为比当前数小的数的个数+1）；
4.查询排名为x的数；
5.求x的前趋（前趋定义为小于x，且最大的数）；
6.求x的后继（后继定义为大于x，且最小的数）。

输入

第一行为n(1 <= n <= 100000), 表示操作的个数，下面n行每行有两个数op(1 <= op <= 6)和x(-1e7 <= x <= 1e7),op表示操作的序号。

输出

对于操作 3、4、5、6 每行输出一个数，表示对应答案。

样例输入 Copy

10
1 106465
4 1
1 317721
1 460929
1 644985
1 84185
1 89851
6 81968
1 492737
5 493598

样例输出 Copy

106465
84185
492737

import java.util.Scanner;
 
public class Main {
 
    public static void main(String[] args) {
        BST bst = new BST();
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        while (n-- > 0) {
            int op = scanner.nextInt();
            int x = scanner.nextInt();
            switch (op) {
                case 1:
                    bst.insert(x);
                    break;
 
                case 2:
                    bst.delete(x);
                    break;
                case 3:
                    System.out.println(bst.getRank(x));
                    break;
 
                case 4:
                    System.out.println(bst.getByRank(x));
                    break;
                case 5:
                    System.out.println(bst.getPredecessor(x));
                    break;
 
                case 6:
                    System.out.println(bst.getSuccessor(x));
                    break;
 
            }
        }
    }
 
    static class TreeNode {
        int val;
        int size;  // 用于维护子树的节点数量
        TreeNode left;
        TreeNode right;
 
        public TreeNode(int val) {
            this.val = val;
            this.size = 1;  // 初始节点数量为1
            this.left = null;
            this.right = null;
        }
    }
 
    static class BST {
        TreeNode root;
 
        // 插入一个数x
        public void insert(int val) {
            root = insertNode(root, val);
        }
 
        private TreeNode insertNode(TreeNode root, int val) {
            if (root == null) {
                return new TreeNode(val);
            }
            if (val < root.val) {
                root.left = insertNode(root.left, val);
            } else {
                root.right = insertNode(root.right, val);
            }
            root.size++;  // 更新子树节点数量
            return root;
        }
 
        // 删除一个数x
        public void delete(int val) {
            root = deleteNode(root, val);
        }
 
        private TreeNode deleteNode(TreeNode root, int val) {
            if (root == null) {
                return root;
            }
            if (val < root.val) {
                root.left = deleteNode(root.left, val);
            } else if (val > root.val) {
                root.right = deleteNode(root.right, val);
            } else {
                if (root.left == null) {
                    return root.right;
                } else if (root.right == null) {
                    return root.left;
                }
                root.val = minValue(root.right);
                root.right = deleteNode(root.right, root.val);
            }
            root.size--;  // 更新子树节点数量
            return root;
        }
 
        private int minValue(TreeNode root) {
            int minVal = root.val;
            while (root.left != null) {
                minVal = root.left.val;
                root = root.left;
            }
            return minVal;
        }
 
        // 查询x数的排名
        public int getRank(int val) {
            return getRankOfNode(root, val);
        }
 
        private int getRankOfNode(TreeNode root, int val) {
            if (root == null) {
                return 0;
            }
            if (val < root.val) {
                return getRankOfNode(root.left, val);
            } else if (val > root.val) {
                return 1 + size(root.left) + getRankOfNode(root.right, val);
            } else {
                return 1 + size(root.left);
            }
        }
 
        private int size(TreeNode node) {
            return node != null ? node.size : 0;
        }
 
        // 查询排名为x的数
        public int getByRank(int rank) {
            return getByRankOfNode(root, rank);
        }
 
        private int getByRankOfNode(TreeNode root, int rank) {
            int leftSize = size(root.left);
            if (rank == leftSize + 1) {
                return root.val;
            } else if (rank <= leftSize) {
                return getByRankOfNode(root.left, rank);
            } else {
                return getByRankOfNode(root.right, rank - leftSize - 1);
            }
        }
 
        // 求x的前趋
        public int getPredecessor(int val) {
            return getPredecessorOfNode(root, val);
        }
 
        private int getPredecessorOfNode(TreeNode root, int val) {
            TreeNode predecessor = null;
            while (root != null) {
                if (val > root.val) {
                    predecessor = root;
                    root = root.right;
                } else {
                    root = root.left;
                }
            }
            return predecessor != null ? predecessor.val : Integer.MIN_VALUE;
        }
 
        // 求x的后继
        public int getSuccessor(int val) {
            return getSuccessorOfNode(root, val);
        }
 
        private int getSuccessorOfNode(TreeNode root, int val) {
            TreeNode successor = null;
            while (root != null) {
                if (val < root.val) {
                    successor = root;
                    root = root.left;
                } else {
                    root = root.right;
                }
            }
            return successor != null ? successor.val : Integer.MAX_VALUE;
        }
    }
 
}