▶ 书中第三章部分程序，加上自己补充的代码，平衡二叉搜索树
● 平衡二叉搜索树
1 package package01; 2 3 import java.util.NoSuchElementException; 4 5 import edu.princeton.cs.algs4.Queue; 6 import edu.princeton.cs.algs4.StdIn; 7 import edu.princeton.cs.algs4.StdOut; 8 9 public class BST<Key extends Comparable<Key>, Value> 10 { 11 private class Node // 二叉树节点 12 { 13 private Key key; 14 private Value val; 15 private Node left, right; 16 private int size; // 节点总数（包括根节点和子树） 17 18 public Node(Key key, Value val, int size) 19 { 20 this.key = key; 21 this.val = val; 22 this.size = size; 23 } 24 } 25 26 private Node root; // 二叉树根节点 27 28 public BST() {} 29 30 public boolean isEmpty() 31 { 32 return size() == 0; 33 } 34 35 public int size() 36 { 37 return size(root); 38 } 39 40 private int size(Node x) 41 { 42 if (x == null) 43 return 0; 44 else 45 return x.size; 46 } 47 48 public boolean contains(Key key) // 判断 key 是否在树中 49 { 50 if (key == null) 51 throw new IllegalArgumentException("\n<contains> key == null.\n"); 52 return get(key) != null; 53 } 54 55 public Value get(Key key) // 查找 56 { 57 if (key == null) 58 throw new IllegalArgumentException("\n<get> key == null.\n"); 59 return getKernel(root, key); 60 } 61 62 private Value getKernel(Node x, Key key) // 查找内核，递归地向下找 63 { 64 if (x == null) 65 return null; 66 int cmp = key.compareTo(x.key); 67 if (cmp < 0) 68 return getKernel(x.left, key); 69 if (cmp > 0) 70 return getKernel(x.right, key); 71 return x.val; 72 } 73 74 public void put(Key key, Value val) // 插入 75 { 76 if (key == null) 77 throw new IllegalArgumentException("\n<put> key == null.\n"); 78 if (val == null) // 空值插入作删除处理 79 delete(key); 80 else 81 root = putKernel(root, key, val); 82 //assert check(); // 对树作修改时需要检查 83 } 84 85 private Node putKernel(Node x, Key key, Value val) // 插入内核，插到适当的位置上去 86 { 87 if (x == null) 88 return new Node(key, val, 1); 89 int cmp = key.compareTo(x.key); 90 if (cmp < 0) 91 x.left = putKernel(x.left, key, val); 92 else if (cmp > 0) 93 x.right = putKernel(x.right, key, val); 94 else 95 x.val = val; 96 x.size = 1 + size(x.left) + size(x.right); 97 return x; 98 } 99 100 public void deleteMin() // 删除最小节点（先根序首节点） 101 { 102 if (isEmpty()) 103 throw new NoSuchElementException("\n<deleteMin> underflow.\n"); 104 root = deleteMinKernel(root); 105 //assert check(); 106 } 107 108 private Node deleteMinKernel(Node x) // 删除最小节点内核 109 { 110 if (x.left == null) // 左子树为空，返回右子树（相当于删除根节点） 111 return x.right; 112 x.left = deleteMinKernel(x.left); // 左子树不空，继续往下找 113 x.size = size(x.left) + size(x.right) + 1; // 重新计算输的大小 114 return x; 115 } 116 117 public void deleteMax() // 删除最大节点（先根序末节点） 118 { 119 if (isEmpty()) 120 throw new NoSuchElementException("\n<deleteMax> underflow.\n"); 121 root = deleteMaxKernel(root); 122 //assert check(); 123 } 124 125 private Node deleteMaxKernel(Node x) 126 { 127 if (x.right == null) // 右子树为空，返回左子树（相当于删除根节点） 128 return x.left; 129 x.right = deleteMaxKernel(x.right); // 右子树不空，继续往下找 130 x.size = size(x.left) + size(x.right) + 1; // 重新计算输的大小 131 132 return x; 133 } 134 135 public void delete(Key key) // 删除指定 key 的节点 136 { 137 if (key == null) 138 throw new IllegalArgumentException("\n<delete> key == null.\n"); 139 root = deleteKernel(root, key); 140 assert check(); 141 } 142 143 private Node deleteKernel(Node x, Key key) // 删除节点内核 144 { 145 if (x == null) 146 return null; 147 int cmp = key.compareTo(x.key); 148 if (cmp < 0) 149 x.left = deleteKernel(x.left, key); 150 else if (cmp > 0) 151 x.right = deleteKernel(x.right, key); 152 else // 找到了目标键 153 { 154 if (x.right == null) // 右子树为空就返回左子树，左子树为空就返回右子树 155 return x.left; 156 if (x.left == null) 157 return x.right; 158 Node t = x; // 左右子树都不空，设这里中根序遍历为 x -> a -> b 159 x = min(t.right); // 找到 t 在中根序的下一个节点 a，赋给 x（结束后 x 的左子树一定为空） 160 x.right = deleteMinKernel(t.right); // 删除节点 a，删除函数返回 a 的下一个节点 b，赋给 x 的右子树 161 x.left = t.left; // 原来的的左子树接到 x 的左子树 162 } 163 x.size = 1 + size(x.left) + size(x.right); 164 return x; 165 } 166 167 public Key min() // 返回最小键 168 { 169 if (isEmpty()) 170 throw new NoSuchElementException("\n<delete> empty.\n"); 171 return minKernel(root).key; 172 } 173 174 private Node minKernel(Node x) // 最小节点内核，需要递归 175 { 176 if (x.left == null) 177 return x; 178 return minKernel(x.left); 179 } 180 181 public Key max() // 返回最大键 182 { 183 if (isEmpty()) 184 throw new NoSuchElementException("\n<max> empty.\n"); 185 return maxKernel(root).key; 186 } 187 188 private Node maxKernel(Node x) // 最大节点内核，需要递归 189 { 190 if (x.right == null) 191 return x; 192 return maxKernel(x.right); 193 } 194 195 public Key floor(Key key) // 返回不大于 key 的最大元素的键，不存在 196 { 197 if (key == null) 198 throw new IllegalArgumentException("\n<floor> key == null.\n"); 199 if (isEmpty()) 200 throw new NoSuchElementException("\n<floor> empty.\n"); 201 Node x = floorKernel(root, key); 202 return (x == null) ? null : return x.key; 203 } 204 205 private Node floorKernel(Node x, Key key) // floor 内核，需要递归 206 { 207 if (x == null) 208 return null; 209 int cmp = key.compareTo(x.key); 210 if (cmp == 0) 211 return x; 212 if (cmp < 0) 213 return floorKernel(x.left, key); 214 Node t = floorKernel(x.right, key); // 目标键较大时需要递归搜索 215 return (t == null) ? x : t; // 在母栈中保存了当前最好的结果 x，没有实现尾递归 216 } 217 218 public Key floor2(Key key) // floor 的尾递归实现 219 { 220 return floor2Kernel(root, key, null); 221 } 222 223 private Key floor2Kernel(Node x, Key key, Key best) // 调用时带上当前已经找到的最佳值 224 { 225 if (x == null) 226 return best; 227 int cmp = key.compareTo(x.key); 228 if (cmp == 0) 229 return x.key; 230 if (cmp < 0) 231 return floor2Kernel(x.left, key, best); 232 return floor2Kernel(x.right, key, x.key); 233 } 234 235 public Key ceiling(Key key) // 返回不小于 key 的最大元素的键 236 { 237 if (key == null) 238 throw new IllegalArgumentException("\n<ceiling> key == null.\n"); 239 if (isEmpty()) 240 throw new NoSuchElementException("\n<ceiling> empty.\n"); 241 Node x = ceilingKernel(root, key); 242 return (x == null) ? null : x.key; 243 } 244 245 private Node ceilingKernel(Node x, Key key) // ceiling 内核，需要递归 246 { 247 if (x == null) 248 return null; 249 int cmp = key.compareTo(x.key); 250 if (cmp == 0) 251 return x; 252 if (cmp > 0) 253 return ceilingKernel(x.right, key); 254 Node t = ceilingKernel(x.left, key); 255 return (t == null) ? x : t; 256 } 257 258 public Key ceiling2(Key key) // ceiling 的尾递归实现 259 { 260 return ceiling2Kernel(root, key, null); 261 } 262 263 private Key ceiling2Kernel(Node x, Key key, Key best) 264 { 265 if (x == null) 266 return best; 267 int cmp = key.compareTo(x.key); 268 if (cmp == 0) 269 return x.key; 270 if (cmp < 0) 271 return ceiling2Kernel(x.left, key, best); 272 return ceiling2Kernel(x.right, key, x.key); 273 } 274 275 public Key select(int k) // 取出排第 k 的元素 276 { 277 if (k < 0 || k >= size()) 278 throw new IllegalArgumentException("\n<select> k < 0 || k >= size().\n"); 279 return selectKernel(root, k).key; 280 } 281 282 private Node selectKernel(Node x, int k) // 取元素内核，需要递归 283 { 284 if (x == null) 285 return null; 286 int t = size(x.left); // 树的元素数用于来计数 287 if (k < t) 288 return selectKernel(x.left, k); 289 if (k > t) 290 return selectKernel(x.right, k - t - 1); 291 return x; 292 } 293 294 public int rank(Key key) // 计算键比 key 小的元素个数 295 { 296 if (key == null) 297 throw new IllegalArgumentException("\n<rank> key == null.\n"); 298 return rankKernel(key, root); 299 } 300 301 private int rankKernel(Key key, Node x) // 计算函数内核，需要递归 302 { 303 if (x == null) 304 return 0; 305 int cmp = key.compareTo(x.key); 306 if (cmp < 0) 307 return rankKernel(key, x.left); 308 if (cmp > 0) 309 return 1 + size(x.left) + rankKernel(key, x.right); 310 return size(x.left); 311 } 312 313 public Iterable<Key> keys() // 创建队列用于迭代器，中根序 314 { 315 if (isEmpty()) 316 return new Queue<Key>(); 317 Key lo = min(), hi = max(); 318 if (lo == null) 319 throw new IllegalArgumentException("\n<iterable> lo == null.\n"); 320 if (hi == null) 321 throw new IllegalArgumentException("\n<iterable> hi == null.\n"); 322 Queue<Key> queue = new Queue<Key>(); 323 keysKernel(root, queue, lo, hi); 324 return queue; 325 } 326 327 private void keysKernel(Node x, Queue<Key> queue, Key lo, Key hi) // 创建迭代器内核，需要递归 328 { 329 if (x == null) 330 return; 331 int cmplo = lo.compareTo(x.key); 332 int cmphi = hi.compareTo(x.key); 333 if (cmplo < 0) 334 keysKernel(x.left, queue, lo, hi); 335 if (cmplo <= 0 && cmphi >= 0) 336 queue.enqueue(x.key); 337 if (cmphi > 0) 338 keysKernel(x.right, queue, lo, hi); 339 } 340 341 public int size(Key lo, Key hi) // 计算键落在给定范围内的元素个数 342 { 343 if (lo == null) 344 throw new IllegalArgumentException("first argument to size() is null"); 345 if (hi == null) 346 throw new IllegalArgumentException("second argument to size() is null"); 347 if (lo.compareTo(hi) > 0) 348 return 0; 349 if (contains(hi)) 350 return rank(hi) - rank(lo) + 1; 351 else 352 return rank(hi) - rank(lo); 353 } 354 355 public int height() // 计算树的高度 356 { 357 return heightKernel(root); 358 } 359 360 private int heightKernel(Node x) // 计算树高度内核，需要递归，空树高度为 -1，根节点高度为 0 361 { 362 if (x == null) 363 return -1; 364 return 1 + Math.max(heightKernel(x.left), heightKernel(x.right)); 365 } 366 367 public Iterable<Key> levelOrder() // 生成先根序队列 368 { 369 Queue<Key> keys = new Queue<Key>(); 370 Queue<Node> queue = new Queue<Node>(); 371 for (queue.enqueue(root); !queue.isEmpty();) 372 { 373 Node x = queue.dequeue(); 374 if (x == null) 375 continue; 376 keys.enqueue(x.key); 377 queue.enqueue(x.left); 378 queue.enqueue(x.right); 379 } 380 return keys; 381 } 382 383 private boolean check() // 检查函数，用于 debug 384 { 385 if (!isBST()) 386 StdOut.println("\n<check> Not in symmetric order.\n"); 387 if (!isSizeConsistent()) 388 StdOut.println("\n<check> Subtree counts not consistent.\n"); 389 if (!isRankConsistent()) 390 StdOut.println("\n<check> Ranks not consistent.\n"); 391 return isBST() && isSizeConsistent() && isRankConsistent(); 392 } 393 394 private boolean isBST() // 检查输的保序性 395 { 396 return isBSTKernel(root, null, null); 397 } 398 399 private boolean isBSTKernel(Node x, Key min, Key max) 400 { 401 if (x == null) 402 return true; 403 if (min != null && x.key.compareTo(min) <= 0) 404 return false; 405 if (max != null && x.key.compareTo(max) >= 0) 406 return false; 407 return isBSTKernel(x.left, min, x.key) && isBSTKernel(x.right, x.key, max); 408 } 409 410 private boolean isSizeConsistent() // 检查树的 size 是否正确 411 { 412 return isSizeConsistentKernel(root); 413 } 414 415 private boolean isSizeConsistentKernel(Node x) 416 { 417 if (x == null) 418 return true; 419 if (x.size != size(x.left) + size(x.right) + 1) 420 return false; 421 return isSizeConsistentKernel(x.left) && isSizeConsistentKernel(x.right); 422 } 423 424 private boolean isRankConsistent() // 检查 rank 和 select 425 426 { 427 for (int i = 0; i < size(); i++) // 检查 rank 是否正确 428 { 429 if (i != rank(select(i))) 430 return false; 431 } 432 for (Key key : keys()) // 检查 select 是否正确 433 { 434 if (key.compareTo(select(rank(key))) != 0) 435 return false; 436 } 437 return true; 438 } 439 440 public static void main(String[] args) 441 { 442 BST<String, Integer> st = new BST<String, Integer>(); 443 for (int i = 0; !StdIn.isEmpty(); i++) // 放进树中 444 { 445 String key = StdIn.readString(); 446 st.put(key, i); 447 } 448 449 for (String s : st.levelOrder()) // 迭代器先根序遍历树 450 StdOut.println(s + " " + st.get(s)); 451 452 StdOut.println(); 453 for (String s : st.keys()) // 按键遍历树 454 StdOut.println(s + " " + st.get(s)); 455 } 456 }