CSC3100

其实是存一下代码

1. AVL的java实现

维护一下每个点左右子树深度差，差绝对值大于2就转，转的方式和treap, splay转的方式差不多。旋转操作可以使两端差归零变得更平衡。

虽然平衡但转的次数太多反而慢了(?)，有空回来整理下，先咕着[旺柴]

import java.util.*;
class TestMain {
    public static void main(String[] args) {
        AvlTree mytree = new AvlTree();
        Scanner jdr = new Scanner(System.in);
        int t = jdr.nextInt();
        while(t > 0) {
            int opt = jdr.nextInt(), x = jdr.nextInt();
            switch (opt) {
                case 1:
                    mytree.insert(x);
                    break;
                case 2:
                    mytree.delete(x);
                    break;
                case 3:
                    System.out.println(mytree.queryRank(x));
                    break;
                case 4:
                    System.out.println(mytree.numAt(x));
                    break;
                case 5:
                    System.out.println(mytree.queryPrev(x));
                    break;
                case 6:
                    System.out.println(mytree.queryPost(x));
                    break;
            }
            t--;
        }
        jdr.close();
        return ;
    }
}

public class AvlTree {
    TreeNode root;
    static TreeNode buffer;
    AvlTree() {
        root = null;
    }
    public void insert(int x) {
        root = insert(root, null, x);
        return ;
    }
    public void delete(int x) {
        root = delete(root, null, x);
        return ;
    }
    public int queryRank(int x) {
        return queryRank(root, x);
    }
    public int numAt(int index) {
        return queryVal(root, index);
    }
    public int queryPrev(int x) {
        findPrev(root, x);
        return buffer.value;
    }
    public int queryPost(int x) {
        findPost(root, x);
        return buffer.value;
    }
    private static TreeNode insert(TreeNode node, TreeNode fa, int x) {
        if(node == null) return new TreeNode(x, fa);
        if(x < node.value) node.child[0] = insert(node.child[0], node, x);
        else if(node.value < x) node.child[1] = insert(node.child[1], node, x);
        else node.num ++;
        node.push_up();
        if(node.diff==-2 || node.diff==2) {
            int p = (node.diff + 2) / 4, q = -node.diff/2;
            if(node.child[p].diff == q)
                node.child[p] = rotate(node.child[p], 1 - p);
            node = rotate(node, p);
        }
        return node;
    }
    private static TreeNode delete(TreeNode node, TreeNode fa, int x) {
        if(node == null) return null;
        if(x < node.value) node.child[0] = delete(node.child[0], node, x);
        else if(node.value < x) node.child[1] = delete(node.child[1], node, x);
        else {
            if(node.child[0]==null && node.child[1]==null) {
                node.num --;
                if(node.num == 0) return null;
            }else {
                int p = (node.diff > 0) ? 1 : 0;
                node = rotate(node, p);
                node.child[1-p] = delete(node.child[1-p], node, x);    
            }
        }
        node.push_up();
        if(node.diff==-2 || node.diff==2) {
            int p = (node.diff + 2) / 4, q = -node.diff/2;
            if(node.child[p].diff == q)
                node.child[p] = rotate(node.child[p], 1 - p);
            node = rotate(node, p);
        }
        return node;
    }
    private static TreeNode rotate(TreeNode node, int direction) {
        int p = direction, q = 1 - direction;
        TreeNode tmp = node.child[p];
        node.child[p] = tmp.child[q];
        tmp.child[q] = node;
        tmp.father = node.father;
        node.father = tmp;
        node.push_up();
        tmp.push_up();
        return tmp;
    }
    private static int queryRank(TreeNode node, int x) {
        if(node == null) return 0;
        if(x < node.value)
            return queryRank(node.child[0], x);
        else if(node.value < x)    
            return queryRank(node.child[1], x) + node.num + node.childWeight(0);
        return node.childWeight(0) + 1;
    }
    private static int queryVal(TreeNode node, int index) {
        if(node == null) return 0;
        if(node.childWeight(0) >= index) 
            return queryVal(node.child[0], index);
        else if(node.childWeight(0) + node.num < index) 
            return queryVal(node.child[1], index - node.childWeight(0) - node.num );
        return node.value;
    }
    private static void findPrev(TreeNode node, int x) {
        if(node == null) return ;
        if(node.value < x) {
            buffer = node;
            findPrev(node.child[1], x);
        }else findPrev(node.child[0], x);
        return ;
    }
    private static void findPost(TreeNode node, int x) {
        if(node == null) return ;
        if(node.value > x) {
            buffer = node;
            findPost(node.child[0], x);
        }else findPost(node.child[1], x);
        return ;
    }
}
class TreeNode {
    int value, diff, height, num, weight;
    TreeNode father;
    TreeNode[] child;
    TreeNode() {}
    TreeNode(int x) {
        value = x;
        diff = 0;
        num = 1;
        weight = 1;
        height = 0;
        father = null;
        child = new TreeNode[2];
    }
    TreeNode(int x, TreeNode fa) {
        value = x;
        diff = 0;
        num = 1;
        weight = 1;
        height = 0;
        father = fa;
        child = new TreeNode[2];
    }
    public void push_up() {
        int h1 = heightOf(child[1]), h0 = heightOf(child[0]);
        height = max(h0, h1) + 1;
        diff = h1 - h0;
        weight = childWeight(0) + childWeight(1) + num;
        return ;
    }
    public int childWeight(int i){
        if(child[i] != null) return child[i].weight;
        return 0;
    }
    private static int heightOf(TreeNode node) {
        if(node != null) return node.height;
        return -1;
    }
    private static int max(int x, int y){
        if(x > y) return x;
        return y;
    }
}