其实是存一下代码

1. AVL的java实现

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

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

  1 import java.util.*;
2 class TestMain {
3 public static void main(String[] args) {
4 AvlTree mytree = new AvlTree();
5 Scanner jdr = new Scanner(System.in);
6 int t = jdr.nextInt();
7 while(t > 0) {
8 int opt = jdr.nextInt(), x = jdr.nextInt();
9 switch (opt) {
10 case 1:
11 mytree.insert(x);
12 break;
13 case 2:
14 mytree.delete(x);
15 break;
16 case 3:
17 System.out.println(mytree.queryRank(x));
18 break;
19 case 4:
20 System.out.println(mytree.numAt(x));
21 break;
22 case 5:
23 System.out.println(mytree.queryPrev(x));
24 break;
25 case 6:
26 System.out.println(mytree.queryPost(x));
27 break;
28 }
29 t--;
30 }
31 jdr.close();
32 return ;
33 }
34 }
35
36 public class AvlTree {
37 TreeNode root;
38 static TreeNode buffer;
39 AvlTree() {
40 root = null;
41 }
42 public void insert(int x) {
43 root = insert(root, null, x);
44 return ;
45 }
46 public void delete(int x) {
47 root = delete(root, null, x);
48 return ;
49 }
50 public int queryRank(int x) {
51 return queryRank(root, x);
52 }
53 public int numAt(int index) {
54 return queryVal(root, index);
55 }
56 public int queryPrev(int x) {
57 findPrev(root, x);
58 return buffer.value;
59 }
60 public int queryPost(int x) {
61 findPost(root, x);
62 return buffer.value;
63 }
64 private static TreeNode insert(TreeNode node, TreeNode fa, int x) {
65 if(node == null) return new TreeNode(x, fa);
66 if(x < node.value) node.child[0] = insert(node.child[0], node, x);
67 else if(node.value < x) node.child[1] = insert(node.child[1], node, x);
68 else node.num ++;
69 node.push_up();
70 if(node.diff==-2 || node.diff==2) {
71 int p = (node.diff + 2) / 4, q = -node.diff/2;
72 if(node.child[p].diff == q)
73 node.child[p] = rotate(node.child[p], 1 - p);
74 node = rotate(node, p);
75 }
76 return node;
77 }
78 private static TreeNode delete(TreeNode node, TreeNode fa, int x) {
79 if(node == null) return null;
80 if(x < node.value) node.child[0] = delete(node.child[0], node, x);
81 else if(node.value < x) node.child[1] = delete(node.child[1], node, x);
82 else {
83 if(node.child[0]==null && node.child[1]==null) {
84 node.num --;
85 if(node.num == 0) return null;
86 }else {
87 int p = (node.diff > 0) ? 1 : 0;
88 node = rotate(node, p);
89 node.child[1-p] = delete(node.child[1-p], node, x);
90 }
91 }
92 node.push_up();
93 if(node.diff==-2 || node.diff==2) {
94 int p = (node.diff + 2) / 4, q = -node.diff/2;
95 if(node.child[p].diff == q)
96 node.child[p] = rotate(node.child[p], 1 - p);
97 node = rotate(node, p);
98 }
99 return node;
100 }
101 private static TreeNode rotate(TreeNode node, int direction) {
102 int p = direction, q = 1 - direction;
103 TreeNode tmp = node.child[p];
104 node.child[p] = tmp.child[q];
105 tmp.child[q] = node;
106 tmp.father = node.father;
107 node.father = tmp;
108 node.push_up();
109 tmp.push_up();
110 return tmp;
111 }
112 private static int queryRank(TreeNode node, int x) {
113 if(node == null) return 0;
114 if(x < node.value)
115 return queryRank(node.child[0], x);
116 else if(node.value < x)
117 return queryRank(node.child[1], x) + node.num + node.childWeight(0);
118 return node.childWeight(0) + 1;
119 }
120 private static int queryVal(TreeNode node, int index) {
121 if(node == null) return 0;
122 if(node.childWeight(0) >= index)
123 return queryVal(node.child[0], index);
124 else if(node.childWeight(0) + node.num < index)
125 return queryVal(node.child[1], index - node.childWeight(0) - node.num );
126 return node.value;
127 }
128 private static void findPrev(TreeNode node, int x) {
129 if(node == null) return ;
130 if(node.value < x) {
131 buffer = node;
132 findPrev(node.child[1], x);
133 }else findPrev(node.child[0], x);
134 return ;
135 }
136 private static void findPost(TreeNode node, int x) {
137 if(node == null) return ;
138 if(node.value > x) {
139 buffer = node;
140 findPost(node.child[0], x);
141 }else findPost(node.child[1], x);
142 return ;
143 }
144 }
145 class TreeNode {
146 int value, diff, height, num, weight;
147 TreeNode father;
148 TreeNode[] child;
149 TreeNode() {}
150 TreeNode(int x) {
151 value = x;
152 diff = 0;
153 num = 1;
154 weight = 1;
155 height = 0;
156 father = null;
157 child = new TreeNode[2];
158 }
159 TreeNode(int x, TreeNode fa) {
160 value = x;
161 diff = 0;
162 num = 1;
163 weight = 1;
164 height = 0;
165 father = fa;
166 child = new TreeNode[2];
167 }
168 public void push_up() {
169 int h1 = heightOf(child[1]), h0 = heightOf(child[0]);
170 height = max(h0, h1) + 1;
171 diff = h1 - h0;
172 weight = childWeight(0) + childWeight(1) + num;
173 return ;
174 }
175 public int childWeight(int i){
176 if(child[i] != null) return child[i].weight;
177 return 0;
178 }
179 private static int heightOf(TreeNode node) {
180 if(node != null) return node.height;
181 return -1;
182 }
183 private static int max(int x, int y){
184 if(x > y) return x;
185 return y;
186 }
187 }

CSC3100的更多相关文章

随机推荐

  1. C#随机打乱列表List元素顺序

    C#随机打乱列表List项目顺序 以下泛型扩展方法,实现了随机打乱泛型列表List<T>的功能 public static List<t> DisorderItems<t ...

  2. 从Spring容器的角度理解Dubbo扩展点的加载时机

    对于Dubbo提供的扩展点,主程序执行的过程中并没有显示调用加载的过程,无论是自激活的Filter还是自适应的ThreadPool.那么这样的扩展点在程序运行的哪个节点调用的呢?跟踪之前性能监控扩展点 ...

  3. 网页外部注入vConsole调试

      概要 本篇介绍一种十分方便的方法为网站添加 vConsole 调试(通过篡改请求外部注入的方式,不需要您是网站的拥有者,主要用于调试线上站点). 之前已经发过一篇<借助FreeHttp为任意 ...

  4. java中的interface(接口)

    概念 usb插槽就是现实中的一个接口 你可以把u盘都插在usb插槽上,而不用担心买来的u盘插不进插槽中不管是插电脑,还是插相机,还是插收音机原因是做usb的厂家和做各种设备的厂家都遵守了统一的规定包括 ...

  5. Android SugarORM(4)

    Android Sugar ORM(4) Android Sugar ORM 数据库迁移 据官网描述, Sugar ORM的设计灵感来自与Rails(没用过, 咱也不知道是啥, 以后也许会学到吧)迁移 ...

  6. NSSCTF-easyupload2.0

    相对于easyupload3.0,这个easyupload2.0就简单的很多,也可以使用和3.0一样的做法,但是应该还是有别的做法,就比如可以使用phtml这个后缀绕过检测 使用BP抓包修改一下 放包 ...

  7. IP欺骗实验

    实验目的 1.掌握IP欺骗的原理 2.学会利用IPSpoof软件工具进行伪造源IP地址的IP欺骗. 实验内容 使用IPSpoof进行本机IP地址修改,与目标主机通信,进行IP欺骗实验 实验环境描述 1 ...

  8. 解除Ubuntu禁止root远程登录

    编辑SSH服务配置文件 编辑SSH服务的配置文件sshd_config,修改SSH的端口和root用户权限. 使用到的命令:(按字母 i 进入编辑模式,按ESC退出编辑模式, :wq 保存退出). r ...

  9. JAVA只要掌握内部类,多继承和单继承都不是问题

    摘要:如果实现java的多继承,其实很简单,关键是对于内部类的特征的掌握,内部类可以继承一个与外部类无关的类,保证了内部类天然独立性,根据这个特性从而实现一个类可以继承多个类的效果. 本文分享自华为云 ...

  10. 使用lrzsz在windows、Linux之间互传文件

    使用xshell自带的传输太慢 使用lrzsz进行文件互传: xshell远程linux 安装工具:yum install -y lrzsz,检查是否安装成功:rpm -qa |grep lrzsz ...