转载自http://lxy2330.iteye.com/blog/1664786

由于平衡二叉树与红黑树都是二叉排序树,又红黑树是对平衡二叉树的一种改进实现,所以它的很多思想算法都来源于排序二叉或平衡二叉树,比如排序二叉树中的添加、删除、查找及查找直接后继节点等,平衡二叉树中的左旋与右旋等都是一样的,所以当看到这些方法时,要多参考以下两节:《二叉排序(搜索)树实现 》与《平衡二叉树实现 》

SortedMap 接口的基于红黑树的实现。此类保证了Map按照升序顺序排列关键字,根据使用的构造方法不同,可能会按照键的类的自然顺序进行排序(Comparable),或者按照创建时所提供的比较(Comparator)进行排序。此实现不是同步的,多个线程同时访问一个同一个map时,一般通过对封装该map的对象进行同步操作来完成,或者使用  Map m = Collections.synchronizedMap(new TreeMap(...)) 方法来包装该map

RED-BLACK树的性质:
1、根元素永远是显色。
2、除根节点外,所有新插入的节点都是红色的。

3、Red规则:红色节点的子节点都是黑色的,不能有两个红色节点相邻。
4、Path规则:从根元素到某个子节点或是只有一个子节点的元素的所有路径中,黑色元素的个数必须相同。

  1. package tree.redblack;
  2. import java.util.AbstractCollection;
  3. import java.util.AbstractMap;
  4. import java.util.AbstractSet;
  5. import java.util.Collection;
  6. import java.util.Comparator;
  7. import java.util.ConcurrentModificationException;
  8. import java.util.Iterator;
  9. import java.util.Map;
  10. import java.util.NoSuchElementException;
  11. import java.util.Set;
  12. import java.util.SortedMap;
  13. public class TreeMap extends AbstractMap implements SortedMap, Cloneable,
  14. java.io.Serializable {
  15. //比较器,用于TreeMap的key的排序,如果为null,则使用key的自然排序法
  16. private Comparator comparator = null;
  17. private transient Entry root = null;//根节点
  18. private transient int size = 0;//树中的节点数
  19. /*
  20. * TreeMap结构被修改的次数,注:结构上修改是指添加或删除一个或多个映射关系的操作, 仅改变与
  21. * 现有键关联的值不是结构上的修改。
  22. *
  23. * 由所有此类的 collection 视图方法(如keySet、values、entrySet三个方法) 所返回的迭代
  24. * 器都是快速失效的:在迭代器创建之后,如果对map修改了结构,除非通过迭代器自身的 remove 或
  25. *  add 方法,其他map自身任何时间任何方式的修改,迭代器都将抛出 ConcurrentModification
  26. *  Exception。因此,面对并发的修改,迭代器很快就完全失效,而不是冒着在将来在不确定的时间点
  27. *  上发生不确定问题的风险。
  28. */
  29. private transient int modCount = 0;
  30. //增加节点后modCount与size都需递增
  31. private void incrementSize() {
  32. modCount++;
  33. size++;
  34. }
  35. private void decrementSize() {
  36. modCount++;
  37. size--;
  38. }
  39. /**
  40. * 默认构造器,构造一个空的map,根据key的自然比较排序。所有插入到map中的节点的key必须实现
  41. * 过自然比较器Comparable接口。
  42. */
  43. public TreeMap() {
  44. }
  45. /**
  46. * 构造一个新的空映射,该映射根据给定的比较器进行排序
  47. */
  48. public TreeMap(Comparator c) {
  49. this.comparator = c;
  50. }
  51. /**
  52. * 构造一个新map,所含的元素与给定的map相同,这个新map按照键的自然顺序进行关键字排序
  53. */
  54. public TreeMap(Map m) {
  55. putAll(m);
  56. }
  57. /**
  58. * 构造一个新的映射,所含的元素与给定的map相同,该映射按照SortedMap相同的排序方式进行排序
  59. */
  60. public TreeMap(SortedMap m) {
  61. comparator = m.comparator();
  62. //...
  63. }
  64. public int size() {
  65. return size;
  66. }
  67. public boolean containsKey(Object key) {
  68. return getEntry(key) != null;
  69. }
  70. public boolean containsValue(Object value) {
  71. return (root == null ? false : (value == null ? valueSearchNull(root)
  72. : valueSearchNonNull(root, value)));
  73. }
  74. //树中是否有value域值为null的节点
  75. private boolean valueSearchNull(Entry n) {
  76. if (n.value == null)
  77. return true;
  78. // 递归在左右子树中查找
  79. return (n.left != null && valueSearchNull(n.left))
  80. || (n.right != null && valueSearchNull(n.right));
  81. }
  82. /*
  83. * 查找指定节点的value值域的节点,因为树是按节的key关键字来排序的,而不是按value排序的,
  84. * 所以在找value时在最坏的情况下遍历整个树
  85. *
  86. * 以二叉树的先序遍历查找
  87. */
  88. private boolean valueSearchNonNull(Entry n, Object value) {
  89. // 先比较根
  90. if (value.equals(n.value))
  91. return true;
  92. // 再比较左,最后再比较右
  93. return (n.left != null && valueSearchNonNull(n.left, value))
  94. || (n.right != null && valueSearchNonNull(n.right, value));
  95. }
  96. //获取指定key的值
  97. public Object get(Object key) {
  98. Entry p = getEntry(key);
  99. return (p == null ? null : p.value);
  100. }
  101. //返回树中第一个(最小的)键,最左边的节点
  102. public Object firstKey() {
  103. return key(firstEntry());
  104. }
  105. /**
  106. * Returns the last (highest) key currently in this sorted map.
  107. *
  108. * @return the last (highest) key currently in this sorted map.
  109. * @throws    NoSuchElementException Map is empty.
  110. */
  111. public Object lastKey() {
  112. return key(lastEntry());
  113. }
  114. /*
  115. * 根据给定的key查找节点,因为 RED-BLACK树也是一种二叉排序树,所以采用在二叉排序树
  116. * 中查找节点的算法来查找
  117. */
  118. private Entry getEntry(Object key) {
  119. Entry p = root;
  120. while (p != null) {
  121. int cmp = compare(key, p.key);
  122. if (cmp == 0)
  123. return p;//找到则返回
  124. else if (cmp < 0)
  125. p = p.left;//如果关键字小于当前节点,则在当前节点的左子树中找
  126. else
  127. p = p.right;//如果关键字大于当前节点,则在当前节点的右子树中找
  128. }
  129. return null;
  130. }
  131. private static Object key(Entry e) {
  132. if (e == null)
  133. throw new NoSuchElementException();
  134. return e.key;
  135. }
  136. /**
  137. * 如果key已存在,将替换原值,并返回原来key所对应的值;如果不存在,则返回 null(注,如果
  138. * 新增key已存在,且为null,返回时也会为null,value为null并不代表key不存在)
  139. */
  140. public Object put(Object key, Object value) {
  141. //插入根节点时不需要调整颜色
  142. Entry t = root;
  143. if (t == null) {
  144. incrementSize();
  145. root = new Entry(key, value, null);
  146. return null;
  147. }
  148. while (true) {
  149. int cmp = compare(key, t.key);
  150. if (cmp == 0) {
  151. return t.setValue(value);
  152. } else if (cmp < 0) {
  153. if (t.left != null) {
  154. t = t.left;
  155. } else {
  156. incrementSize();
  157. t.left = new Entry(key, value, t);
  158. //需要调整颜色
  159. fixAfterInsertion(t.left);
  160. return null;
  161. }
  162. } else { // cmp > 0
  163. if (t.right != null) {
  164. t = t.right;
  165. } else {
  166. incrementSize();
  167. t.right = new Entry(key, value, t);
  168. //需要调整颜色
  169. fixAfterInsertion(t.right);
  170. return null;
  171. }
  172. }
  173. }
  174. }
  175. //从map中删除指定的key节点,并返回value,如果不存在或value本身就是null时,返回null
  176. public Object remove(Object key) {
  177. Entry p = getEntry(key);
  178. if (p == null)
  179. return null;
  180. Object oldValue = p.value;
  181. deleteEntry(p);
  182. return oldValue;
  183. }
  184. public void clear() {
  185. modCount++;
  186. size = 0;
  187. root = null;
  188. }
  189. public Object clone() {
  190. TreeMap clone = null;
  191. try {
  192. //调整父类的克隆方法
  193. clone = (TreeMap) super.clone();
  194. } catch (CloneNotSupportedException e) {
  195. throw new InternalError();
  196. }
  197. // Put clone into "virgin" state (except for comparator)
  198. clone.root = null;
  199. clone.size = 0;
  200. clone.modCount = 0;
  201. clone.entrySet = null;
  202. //...
  203. return clone;
  204. }
  205. // Views
  206. /**
  207. * key-value(键-值对)视图,即该set视图里是一个个的Entry实体节点
  208. */
  209. private transient volatile Set entrySet = null;
  210. //以下两个字段是从父类AbstractMap拷贝过来的,因为在该类与父类不在一个包中,所以不可见
  211. transient volatile Set keySet = null;//key视图,set视图里是一个个Entry实体节点的key
  212. //value视图,collection视图里是一个个Entry实体节点的value
  213. transient volatile Collection values = null;
  214. public Set keySet() {
  215. if (keySet == null) {
  216. //keySet视图实现
  217. keySet = new AbstractSet() {
  218. public Iterator iterator() {
  219. //只能对key进行迭代
  220. return new KeyIterator();
  221. }
  222. public int size() {
  223. return TreeMap.this.size();
  224. }
  225. //...
  226. };
  227. }
  228. return keySet;
  229. }
  230. //value视图中的value排列的顺序保持不变,实质上还是在entrySet视图上迭代的
  231. public Collection values() {
  232. if (values == null) {
  233. //value视图实现
  234. values = new AbstractCollection() {
  235. public Iterator iterator() {
  236. //只能迭代value
  237. return new ValueIterator();
  238. }
  239. public int size() {
  240. return TreeMap.this.size();
  241. }
  242. //...
  243. };
  244. }
  245. return values;
  246. }
  247. //key-value 视图,即Entry节点视图
  248. public Set entrySet() {
  249. if (entrySet == null) {
  250. entrySet = new AbstractSet() {
  251. public Iterator iterator() {
  252. //对Entry节点迭代
  253. return new EntryIterator();
  254. }
  255. //...
  256. public int size() {
  257. return TreeMap.this.size();
  258. }
  259. };
  260. }
  261. return entrySet;
  262. }
  263. //Entry迭代器
  264. private class EntryIterator implements Iterator {
  265. private int expectedModCount = TreeMap.this.modCount;
  266. private Entry lastReturned = null;//指向最后一次next操作所返回的节点
  267. Entry next;//指向当前next()操作要返回的节点
  268. EntryIterator() {
  269. next = firstEntry();//开始时next指向最左边的节点,即中序遍历序列中的第一个节点
  270. }
  271. // Used by SubMapEntryIterator
  272. EntryIterator(Entry first) {
  273. next = first;
  274. }
  275. public boolean hasNext() {
  276. //如果next没有指向null,则表示当前next指向的节点还有
  277. return next != null;
  278. }
  279. //KeyIterator与ValueIterator两迭代器的next()方法实现都是调整此方法来实现的
  280. final Entry nextEntry() {
  281. if (next == null)
  282. throw new NoSuchElementException();
  283. if (modCount != expectedModCount)
  284. throw new ConcurrentModificationException();
  285. lastReturned = next;//先取
  286. next = successor(next);//next再下移
  287. return lastReturned;
  288. }
  289. public Object next() {
  290. //对Entry进行迭代
  291. return nextEntry();
  292. }
  293. public void remove() {
  294. if (lastReturned == null)
  295. throw new IllegalStateException();
  296. if (modCount != expectedModCount)
  297. throw new ConcurrentModificationException();
  298. //如果删除的节点左右子树都存在,则删除后next指针需后退到lastReturned的位置,
  299. //具体为什么,请参考二叉搜索树的实现 BinSearchTree.java 相应方法
  300. if (lastReturned.left != null && lastReturned.right != null)
  301. next = lastReturned;
  302. deleteEntry(lastReturned);
  303. expectedModCount++;
  304. lastReturned = null;
  305. }
  306. }
  307. //KeyIterator是在EntryIterator的基础上只对key进行迭代罢了
  308. private class KeyIterator extends EntryIterator {
  309. public Object next() {
  310. return nextEntry().key;
  311. }
  312. }
  313. //ValueIterator是在EntryIterator的基础上只对value进行迭代罢了
  314. private class ValueIterator extends EntryIterator {
  315. public Object next() {
  316. return nextEntry().value;
  317. }
  318. }
  319. //在这里决定是使用 Comparator 还 Comparable 比较器
  320. private int compare(Object k1, Object k2) {
  321. return (comparator == null ? ((Comparable) k1).compareTo(k2) : comparator
  322. .compare(k1, k2));
  323. }
  324. private static boolean valEquals(Object o1, Object o2) {
  325. return (o1 == null ? o2 == null : o1.equals(o2));
  326. }
  327. private static final boolean RED = false;//false代表红
  328. private static final boolean BLACK = true;//true代表黑
  329. /**
  330. * 树中的节点结构体实现,实现了Map.Entry接口,它是双向的,即可以从子找到父,也可从
  331. * 父到子节点
  332. */
  333. static class Entry implements Map.Entry {
  334. Object key;//数据域key
  335. Object value;//数据域value
  336. Entry left = null;//左指针
  337. Entry right = null;//右指针
  338. Entry parent;//父指针
  339. boolean color = BLACK;//节点着色,相当于平衡二叉排序树中的平衡因子
  340. Entry(Object key, Object value, Entry parent) {
  341. this.key = key;
  342. this.value = value;
  343. this.parent = parent;
  344. }
  345. public Object getKey() {
  346. return key;
  347. }
  348. public Object getValue() {
  349. return value;
  350. }
  351. public Object setValue(Object value) {
  352. Object oldValue = this.value;
  353. this.value = value;
  354. return oldValue;
  355. }
  356. //...
  357. public String toString() {
  358. return key + "=" + value;
  359. }
  360. }
  361. //取树中最左边的节点,即key最小的节点
  362. private Entry firstEntry() {
  363. Entry p = root;
  364. if (p != null)
  365. while (p.left != null)
  366. p = p.left;
  367. return p;
  368. }
  369. //取树中最右边的节点,即key最大的节点
  370. private Entry lastEntry() {
  371. Entry p = root;
  372. if (p != null)
  373. while (p.right != null)
  374. p = p.right;
  375. return p;
  376. }
  377. //查找某节点的中序遍历的直接后继节点,具体请参见BinSearchTree.java 相应方法
  378. private Entry successor(Entry t) {
  379. if (t == null)
  380. return null;
  381. else if (t.right != null) {
  382. Entry p = t.right;
  383. while (p.left != null)
  384. p = p.left;
  385. return p;
  386. } else {
  387. Entry p = t.parent;
  388. Entry ch = t;
  389. while (p != null && ch == p.right) {
  390. ch = p;
  391. p = p.parent;
  392. }
  393. return p;
  394. }
  395. }
  396. //平衡操作
  397. private static boolean colorOf(Entry p) {
  398. //注,如果为null,则返回为黑色,即如果求某个节点的子节点颜色,但子节点不存在时也会返回黑色
  399. return (p == null ? BLACK : p.color);
  400. }
  401. private static Entry parentOf(Entry p) {
  402. return (p == null ? null : p.parent);
  403. }
  404. private static void setColor(Entry p, boolean c) {
  405. if (p != null)
  406. p.color = c;
  407. }
  408. private static Entry leftOf(Entry p) {
  409. return (p == null) ? null : p.left;
  410. }
  411. private static Entry rightOf(Entry p) {
  412. return (p == null) ? null : p.right;
  413. }
  414. //左旋,具体请参见AVLTree.java相应方法
  415. private void rotateLeft(Entry p) {
  416. Entry r = p.right;
  417. p.right = r.left;
  418. if (r.left != null)
  419. r.left.parent = p;
  420. r.parent = p.parent;
  421. if (p.parent == null)
  422. root = r;
  423. else if (p.parent.left == p)
  424. p.parent.left = r;
  425. else
  426. p.parent.right = r;
  427. r.left = p;
  428. p.parent = r;
  429. }
  430. //右旋,具体请参见AVLTree.java相应方法
  431. private void rotateRight(Entry p) {
  432. Entry l = p.left;
  433. p.left = l.right;
  434. if (l.right != null)
  435. l.right.parent = p;
  436. l.parent = p.parent;
  437. if (p.parent == null)
  438. root = l;
  439. else if (p.parent.right == p)
  440. p.parent.right = l;
  441. else
  442. p.parent.left = l;
  443. l.right = p;
  444. p.parent = l;
  445. }
  446. /** From CLR **/
  447. private void fixAfterInsertion(Entry x) {
  448. //插入的节点为红色
  449. x.color = RED;
  450. /*
  451. * 添加节点时,因为在上面将新增节点设置成了红色,所以添加后是不会打破 Path规则 的,但是
  452. * 有可能会打破 Red规则,又打破 Red规则 的前提是父节点是红色的才可能,所以这里的循环条
  453. * 件就是父节点必须是红色的才需调整
  454. *
  455. * 1、如果x为根,则不需要重新染色与旋转,因为最后会将根再次染成BLACK
  456. * 2、如果x的父节点color为黑色,也没必要进行重排了,因为red规则没有被破坏
  457. * 如果上面两个条件不满足,则一直循环,这里x != null 条件也是不可少的,传递进来的值
  458. * 与循环终止时都能可能为null
  459. */
  460. while (x != null && x != root && x.parent.color == RED) {
  461. //一、x的父节点处于左子节点时
  462. if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
  463. //y指向x的右叔,注,有可能为NULL
  464. Entry y = rightOf(parentOf(parentOf(x)));
  465. //如果y为红色
  466. if (colorOf(y) == RED) {//如果条件成立,则y不能可为空
  467. /*
  468. * 情况1:colorOf(y) == RED
  469. *
  470. * 此情况下y不可能为null,因为 colorOf(null) == BLACK,所以此情况
  471. * 下右叔一定存在,既然右叔是红色,所以爷爷节点50只能是黑色了,否则打破
  472. * 了Red规则了。30也肯定是红色了,因为进行while循环前提条件就是父节点
  473. * 一定是红色的
  474. *                         着色
  475. *           .              →              .
  476. *           .                             .
  477. *           50B                      x → 50R
  478. *           /\                            /\
  479. *        30R  90R ← y(右叔)             30B  90B ← y
  480. *           \                            \
  481. *      x → 40R                          40R
  482. *
  483. * 此情况下不需要旋转,完成着色后继续循环
  484. */
  485. //将x节点的父节点的着黑
  486. setColor(parentOf(x), BLACK);
  487. //将x的右叔的着黑
  488. setColor(y, BLACK);
  489. //将x的爷爷着红
  490. setColor(parentOf(parentOf(x)), RED);
  491. /*
  492. * 完成操作后,我们发现x向上移动了两层,因此循环的最大次数是树的高度的一
  493. * 半,这也就是TreeMap中的put方法的最大执行时间为 O(logn) 原因所在了
  494. */
  495. x = parentOf(parentOf(x));//再将x指向爷爷
  496. }//如果y为黑色
  497. else {
  498. if (x == rightOf(parentOf(x))) {
  499. /*
  500. * 情况2:colorOf(y) == BLACK,且x为父的右子节点
  501. *
  502. * 此情况下,y一定是null,为什么?因为插入的节点40的父节点30为红色
  503. * (又为什么?因为进行while循环的前提就是父为红色啊),所以30的父
  504. * 节点只能为黑色了(又为什么?因为如果是红色的话,早就打破了Red规则
  505. * 了),现进入到此分支时前提是y必须是黑色的,如果y真的存在,则Path
  506. * 规则又将被打破,所以此情况下的y一定是null,这样才满足Path规则
  507. *
  508. * ====实质上此种情况就是将问题2转换成转换成问题3来操作====
  509. *
  510. *                   绕30左旋
  511. *        .            →             .
  512. *        .                          .
  513. *       50B                        50B
  514. *        /                          /
  515. *      30R  (Y为NULL)             40R
  516. *        \                         /
  517. *   x → 40R                   x → 30R
  518. */
  519. x = parentOf(x);
  520. rotateLeft(x);
  521. }
  522. /*
  523. * 情况3:colorOf(y) == BLACK,且x为父的左子节点
  524. *
  525. * 如果x为父的右子节点,经过上面情况2的处理,已经将其转换成情况3了,此种
  526. * 情况下的y也一定为null,与第2种情况道理是一样的
  527. *
  528. *                    着色               绕50右旋
  529. *        .            →         .       →       .
  530. *        .                      .               .
  531. *       50B                    50R            40B
  532. *        /                      /               /\
  533. *      40R  (Y为NULL)          40B        x → 30R 50R
  534. *       /                      /
  535. * x → 30R                 x → 30R
  536. *
  537. * 处理后,下次循环自动会终止,因为此情况处理后x的父节点总是黑色的,所以
  538. * 循环一定会终止于下次
  539. */
  540. setColor(parentOf(x), BLACK);//x的父着黑
  541. setColor(parentOf(parentOf(x)), RED);//x的爷着红
  542. if (parentOf(parentOf(x)) != null)
  543. rotateRight(parentOf(parentOf(x)));//绕爷爷右旋
  544. }
  545. }//二、x的父节点处于右子节点时,与第一种对称
  546. else {
  547. //x的左叔
  548. Entry y = leftOf(parentOf(parentOf(x)));
  549. //如果左叔为红色
  550. if (colorOf(y) == RED) {
  551. /*
  552. * 情况1:colorOf(y) == RED,即左叔为红色
  553. *
  554. * 此情况下y不可能为null,因为 colorOf(null) == BLACK,所以此情况
  555. * 下左叔一定存在,既然左叔是红色,所以爷爷节点50只能是黑色了,否则打破
  556. * 了Red规则了。90也肯定是红色了,因为进行while循环前提条件就是父节点
  557. * 一定是红色的
  558. *                         着色
  559. *           .              →              .
  560. *           .                             .
  561. *           50B                      x → 50R
  562. *           /\                            /\
  563. * y(左叔)→30R  90R                      30B 90B ← y
  564. *              \                             \
  565. *          x → 100R                          100R
  566. *
  567. * 此情况下不需要旋转,完成着色后继续循环
  568. */
  569. setColor(parentOf(x), BLACK);
  570. setColor(y, BLACK);
  571. setColor(parentOf(parentOf(x)), RED);
  572. /*
  573. * 完成操作后,我们发现x向上移动了两层,因此循环的最大次数是树的高度的一
  574. * 半,这也就是TreeMap中的put方法的最大执行时间为 O(logn) 原因所在了
  575. */
  576. x = parentOf(parentOf(x));//再将x指向爷爷
  577. }//如果y为黑色
  578. else {
  579. if (x == leftOf(parentOf(x))) {
  580. /*
  581. * 情况2:colorOf(y) == BLACK(左叔为黑),且x为父的左子节点
  582. *
  583. * 此情况下,y一定是null,为什么?因为插入的节点60的父节点90为红色
  584. * ,所以90的父节点只能为黑色了,现进入到此分支时前提是y必须是黑色的
  585. * ,如果y真的存在,则Path规则又将被打破,所以此情况下的y一定是null
  586. * ,这样才满足Path规则
  587. *
  588. * ====实质上此种情况就是将问题2转换成转换成问题3来操作====
  589. *
  590. *                   绕90右旋
  591. *          .            →             .
  592. *          .                          .
  593. *          50B                        50B
  594. *           \                          \
  595. *(Y为NULL)  90R                        60R
  596. *           /                           \
  597. *      x → 60R                      x → 90R
  598. */
  599. x = parentOf(x);
  600. rotateRight(x);
  601. }
  602. /*
  603. * 情况3:colorOf(y) == BLACK,且x为父的右子节点
  604. *
  605. * 如果x为父的左子节点,经过上面情况2的处理,已经将其转换成情况3了,此种
  606. * 情况下的y也一定为null,与第2种情况道理是一样的
  607. *
  608. *                    着色               绕50左旋
  609. *         .            →         .       →       .
  610. *         .                      .               .
  611. *        50B                    50R            90B
  612. *         \                      \               /\
  613. *(Y为NULL) 90R                   90B       x → 50R 95R
  614. *           \                     \
  615. *       x → 95R               x → 95R
  616. *
  617. * 处理后,下次循环自动会终止,因为此情况处理后x的父节点总是黑色的,所以
  618. * 循环一定会终止于下次
  619. */
  620. setColor(parentOf(x), BLACK);//x的父着黑
  621. setColor(parentOf(parentOf(x)), RED);//x的爷着红
  622. if (parentOf(parentOf(x)) != null)
  623. rotateLeft(parentOf(parentOf(x)));//绕爷爷左旋
  624. }
  625. }
  626. }
  627. root.color = BLACK;//不管怎样调整,最后根节点都要着黑
  628. }
  629. //删除节点p,然后重新调整
  630. private void deleteEntry(Entry p) {
  631. decrementSize();
  632. /*
  633. * 如果删除的节点p有左右子树时,将问题转换成删除叶子节点或只有一个子节点的节点问题,具体
  634. * 过程:使用中序遍历直接后s继的数据域值(key与value)拷贝到p的相应数据域值,然后将p指
  635. * 向直接后继s,这样待删除的节点就变成了s,问题已转换成删除叶节点或只有一个子节点的问题了
  636. */
  637. if (p.left != null && p.right != null) {
  638. Entry s = successor(p);
  639. p.key = s.key;
  640. p.value = s.value;
  641. p = s;
  642. }
  643. //replacement用来替换即将被删除节点p
  644. Entry replacement = (p.left != null ? p.left : p.right);
  645. //如果待删除的元素有子节点(如果有,则也有且仅有一个子节点)
  646. if (replacement != null) {
  647. // 重新设置替换节点的父
  648. replacement.parent = p.parent;
  649. //如果待删除节点的为根节点
  650. if (p.parent == null)
  651. root = replacement;//则替换元素将成为根
  652. else if (p == p.parent.left)
  653. //否则如果待删除节点为左节点,则使待删除节点的父的左指针指向替换节点
  654. p.parent.left = replacement;
  655. else
  656. //否则如果待删除节点为右节点,则使待删除节点的父的右指针指向替换节点
  657. p.parent.right = replacement;
  658. // 解除p与其他节点的关系
  659. p.left = p.right = p.parent = null;
  660. /*
  661. * 因为被删除的节点只有两种节点: 叶子节点、只有一个子节点的节点
  662. *
  663. * 如果删除的是只有一个子节点的节点时,根据路径规则,被删除节点一定是黑色的,而子节点
  664. * 一定是红色的,这时删除操作过程就是删除了一个黑红节点而在删除位置上又放置了一个红色
  665. * 节点,因此,删除一个有一个子节点的节点时,Red与Path规则都有可能打破
  666. */
  667. if (p.color == BLACK)//???这里的条件好像是多余的,因为p一定是黑,难道另有玄机?
  668. //删除后从替换节点replacement位置向根方向调整
  669. fixAfterDeletion(replacement);
  670. } else if (p.parent == null) { // 如果待删除节点为根,则置root为null
  671. root = null;
  672. } else { // 如果删除的是叶子节点
  673. /*
  674. * 如果删除的是叶子节点,不管该叶子节点是红还是黑,则 Red规则 在删除后不可能被打破,
  675. * 所以此情况下只有可能打破 Path规则 ,但打破的前提是被删除的节点是黑色的,因为只有
  676. * 黑色节点才影响Path路径规则,所以调整的前提是 p.color == BLACK,即被删除的叶
  677. * 节点是黑色的
  678. */
  679. if (p.color == BLACK)
  680. //删除前从即将被删除节点p位置向根方向调整
  681. fixAfterDeletion(p);
  682. //???此条件好像多余,因为如果不成立,则走上面那个分支了,难道另藏玄机
  683. if (p.parent != null) {
  684. if (p == p.parent.left)
  685. p.parent.left = null;
  686. else if (p == p.parent.right)
  687. p.parent.right = null;
  688. p.parent = null;//解除p与其他节点的关系
  689. }
  690. }
  691. }
  692. //删除节点后调整
  693. private void fixAfterDeletion(Entry x) {
  694. //直循环到根节点或红色止
  695. while (x != root && colorOf(x) == BLACK) {
  696. //x为左子节点
  697. if (x == leftOf(parentOf(x))) {
  698. //x的同胞
  699. Entry sib = rightOf(parentOf(x));//有可能为null
  700. if (colorOf(sib) == RED) {//同胞不可能为null
  701. /*
  702. * 情况1:colorOf(sib) == RED,即右叔存在且为红
  703. *              通过执行上面deleteEntry后,x、p均指向后继65
  704. *        p → 60B             →           65B
  705. *            /  \                        /  \
  706. *          50B   70B                   50B   70B
  707. *          /\    /  \                  /\    /  \
  708. *       45B 55B 65B 80R             45B 55B 65B 80R ← sib
  709. *                   / \                     ↑   /  \
  710. *                 75B 87B                 x、p 75B 87B
  711. *  着色                         绕70左旋
  712. *   →        65B               →           65B
  713. *            /  \                          /  \
  714. *          50B   70R                     50B   80B
  715. *          /\    /  \                    /\    / \
  716. *       45B 55B 65B 80B ← sib         45B 55B 70R 87B
  717. *                ↑   / \                      /  \
  718. *              x、p 75B 87B            x、p → 65B 75B ← sib
  719. *  x现有一个新的同胞节点,该节点为黑,现将情况1转向其他3种情况
  720. */
  721. setColor(sib, BLACK);//置同胞为黑
  722. setColor(parentOf(x), RED);//置父为红
  723. rotateLeft(parentOf(x));//左旋
  724. sib = rightOf(parentOf(x));//再处理同胞节点
  725. }
  726. if (colorOf(leftOf(sib)) == BLACK && colorOf(rightOf(sib)) == BLACK) {
  727. /*
  728. * 情况2:
  729. * colorOf(leftOf(sib))==BLACK && colorOf(rightOf(sib))==BLACK
  730. * 即同胞不存在或同胞存在时为黑且没有子节点的情况
  731. *
  732. * 现接着上面情况1结束后的那棵树处理
  733. * 着色                       再将x指向父(70R)继续处理
  734. *  →      65B                   →           ...
  735. *         /  \
  736. *       50B   80B
  737. *       /\     / \
  738. *     45B 55B 70R 87B
  739. *             / \
  740. *     x、p → 65B 75R ← sib
  741. *
  742. * 处理完后,x为红,因此结束循环,然后设置x的颜色为黑,并从此返回
  743. * deleteEntry方法,此时p所指向的节点已被从其父节点解除链接
  744. */
  745. setColor(sib, RED);
  746. x = parentOf(x);
  747. } else {
  748. if (colorOf(rightOf(sib)) == BLACK) {
  749. /*
  750. * 情况3:经过情况2后,此时同胞节点左子节点必为红
  751. *
  752. * 假设在开始while循环之前有如下树:
  753. *  →      65B
  754. *         /  \
  755. *       50B   80R
  756. *      / \    /  \
  757. *    45B 55B 70B  90B
  758. *            / \   / \
  759. *     x → 65B 75B 85R 95B
  760. *             ↗  / \
  761. *          sib  82B 87B
  762. *
  763. * 情况2被应用,因此将75的颜色设置为红,并令 x = parentOf(x)后第
  764. * 一遍循环结束。第二遍循环开始时,会应用情况3,此时同胞节点为90,树
  765. * 如下图:
  766. * 第一次循环完                  着色
  767. *    →    65B                →          65B
  768. *        /   \                          /  \
  769. *      50B    80R                    50B    80R
  770. *     / \     /  \                   / \    /  \
  771. *   45B 55B 70B   90B ← sib       45B 55B 70B   90R ← sib
  772. *         ↗/ \    / \                  ↗/ \     / \
  773. *       x 65B 75R 85R 95B             x 65B 75R 85B 95B
  774. *                 / \                           / \
  775. *               82B 87B                       82B 87B
  776. *
  777. * 绕90右旋后并修改sib指向           进行下一步循环,应用情况4
  778. *    →          65B                      → ...
  779. *              /   \
  780. *            50B    80R
  781. *           / \     /  \
  782. *         45B 55B 70B   85B ← sib
  783. *               ↗/ \    / \
  784. *             x 65B 75R 82B 90R
  785. *                           / \
  786. *                         87B 95B
  787. *
  788. * 一旦情况3被应用,则同胞节点的右子节点将设置为 RED,因此情况4在情况
  789. * 3之后应用,为了不在下一次循环中应用情况4,直接将情况4的代码放在了
  790. * 情况3的后面
  791. */
  792. setColor(leftOf(sib), BLACK);
  793. setColor(sib, RED);
  794. rotateRight(sib);
  795. sib = rightOf(parentOf(x));
  796. }
  797. /*
  798. * 情况4:经过情况3后剩下的情况4,此时同胞节点的右子节点是红
  799. *
  800. * 接着第3种情况处理:
  801. *
  802. *   着色                    绕80左旋
  803. *    →       65B            →              65B
  804. *           /   \                          /  \
  805. *         50B    80B                     50B   85R ← sib
  806. *        / \     /  \                   / \    /  \
  807. *      45B 55B 70B   85R ← sib        45B 55B 80B 90B
  808. *            ↗/ \    / \                     / \   \
  809. *          x 65B 75R 82B 90B            x → 70B 87B 95B
  810. *                        / \                 /
  811. *                      87B 95B         p → 65B
  812. *
  813. * 循环结束后返回到 deleteEntry 方法,删除65节点即完成删除操作过程
  814. */
  815. setColor(sib, colorOf(parentOf(x)));
  816. setColor(parentOf(x), BLACK);
  817. setColor(rightOf(sib), BLACK);
  818. rotateLeft(parentOf(x));
  819. //情况3与4被应用后,x将被设置为根节点,同时,这也是循环的最后一次
  820. x = root;
  821. }
  822. } else { // 与上面对称
  823. Entry sib = leftOf(parentOf(x));
  824. if (colorOf(sib) == RED) {
  825. setColor(sib, BLACK);
  826. setColor(parentOf(x), RED);
  827. rotateRight(parentOf(x));
  828. sib = leftOf(parentOf(x));
  829. }
  830. if (colorOf(rightOf(sib)) == BLACK && colorOf(leftOf(sib)) == BLACK) {
  831. setColor(sib, RED);
  832. x = parentOf(x);
  833. } else {
  834. if (colorOf(leftOf(sib)) == BLACK) {
  835. setColor(rightOf(sib), BLACK);
  836. setColor(sib, RED);
  837. rotateLeft(sib);
  838. sib = leftOf(parentOf(x));
  839. }
  840. setColor(sib, colorOf(parentOf(x)));
  841. setColor(parentOf(x), BLACK);
  842. setColor(leftOf(sib), BLACK);
  843. rotateRight(parentOf(x));
  844. x = root;
  845. }
  846. }
  847. }
  848. //退出循环时x为根或为红色,直接将其值为黑色即可
  849. setColor(x, BLACK);
  850. }
  851. }
  1. package tree.redblack;
  2. import java.util.AbstractCollection;
  3. import java.util.AbstractMap;
  4. import java.util.AbstractSet;
  5. import java.util.Collection;
  6. import java.util.Comparator;
  7. import java.util.ConcurrentModificationException;
  8. import java.util.Iterator;
  9. import java.util.Map;
  10. import java.util.NoSuchElementException;
  11. import java.util.Set;
  12. import java.util.SortedMap;
  13. public class TreeMap extends AbstractMap implements SortedMap, Cloneable,
  14. java.io.Serializable {
  15. //比较器,用于TreeMap的key的排序,如果为null,则使用key的自然排序法
  16. private Comparator comparator = null;
  17. private transient Entry root = null;//根节点
  18. private transient int size = 0;//树中的节点数
  19. /*
  20. * TreeMap结构被修改的次数,注:结构上修改是指添加或删除一个或多个映射关系的操作, 仅改变与
  21. * 现有键关联的值不是结构上的修改。
  22. *
  23. * 由所有此类的 collection 视图方法(如keySet、values、entrySet三个方法) 所返回的迭代
  24. * 器都是快速失效的:在迭代器创建之后,如果对map修改了结构,除非通过迭代器自身的 remove 或
  25. *  add 方法,其他map自身任何时间任何方式的修改,迭代器都将抛出 ConcurrentModification
  26. *  Exception。因此,面对并发的修改,迭代器很快就完全失效,而不是冒着在将来在不确定的时间点
  27. *  上发生不确定问题的风险。
  28. */
  29. private transient int modCount = 0;
  30. //增加节点后modCount与size都需递增
  31. private void incrementSize() {
  32. modCount++;
  33. size++;
  34. }
  35. private void decrementSize() {
  36. modCount++;
  37. size--;
  38. }
  39. /**
  40. * 默认构造器,构造一个空的map,根据key的自然比较排序。所有插入到map中的节点的key必须实现
  41. * 过自然比较器Comparable接口。
  42. */
  43. public TreeMap() {
  44. }
  45. /**
  46. * 构造一个新的空映射,该映射根据给定的比较器进行排序
  47. */
  48. public TreeMap(Comparator c) {
  49. this.comparator = c;
  50. }
  51. /**
  52. * 构造一个新map,所含的元素与给定的map相同,这个新map按照键的自然顺序进行关键字排序
  53. */
  54. public TreeMap(Map m) {
  55. putAll(m);
  56. }
  57. /**
  58. * 构造一个新的映射,所含的元素与给定的map相同,该映射按照SortedMap相同的排序方式进行排序
  59. */
  60. public TreeMap(SortedMap m) {
  61. comparator = m.comparator();
  62. //...
  63. }
  64. public int size() {
  65. return size;
  66. }
  67. public boolean containsKey(Object key) {
  68. return getEntry(key) != null;
  69. }
  70. public boolean containsValue(Object value) {
  71. return (root == null ? false : (value == null ? valueSearchNull(root)
  72. : valueSearchNonNull(root, value)));
  73. }
  74. //树中是否有value域值为null的节点
  75. private boolean valueSearchNull(Entry n) {
  76. if (n.value == null)
  77. return true;
  78. // 递归在左右子树中查找
  79. return (n.left != null && valueSearchNull(n.left))
  80. || (n.right != null && valueSearchNull(n.right));
  81. }
  82. /*
  83. * 查找指定节点的value值域的节点,因为树是按节的key关键字来排序的,而不是按value排序的,
  84. * 所以在找value时在最坏的情况下遍历整个树
  85. *
  86. * 以二叉树的先序遍历查找
  87. */
  88. private boolean valueSearchNonNull(Entry n, Object value) {
  89. // 先比较根
  90. if (value.equals(n.value))
  91. return true;
  92. // 再比较左,最后再比较右
  93. return (n.left != null && valueSearchNonNull(n.left, value))
  94. || (n.right != null && valueSearchNonNull(n.right, value));
  95. }
  96. //获取指定key的值
  97. public Object get(Object key) {
  98. Entry p = getEntry(key);
  99. return (p == null ? null : p.value);
  100. }
  101. //返回树中第一个(最小的)键,最左边的节点
  102. public Object firstKey() {
  103. return key(firstEntry());
  104. }
  105. /**
  106. * Returns the last (highest) key currently in this sorted map.
  107. *
  108. * @return the last (highest) key currently in this sorted map.
  109. * @throws    NoSuchElementException Map is empty.
  110. */
  111. public Object lastKey() {
  112. return key(lastEntry());
  113. }
  114. /*
  115. * 根据给定的key查找节点,因为 RED-BLACK树也是一种二叉排序树,所以采用在二叉排序树
  116. * 中查找节点的算法来查找
  117. */
  118. private Entry getEntry(Object key) {
  119. Entry p = root;
  120. while (p != null) {
  121. int cmp = compare(key, p.key);
  122. if (cmp == 0)
  123. return p;//找到则返回
  124. else if (cmp < 0)
  125. p = p.left;//如果关键字小于当前节点,则在当前节点的左子树中找
  126. else
  127. p = p.right;//如果关键字大于当前节点,则在当前节点的右子树中找
  128. }
  129. return null;
  130. }
  131. private static Object key(Entry e) {
  132. if (e == null)
  133. throw new NoSuchElementException();
  134. return e.key;
  135. }
  136. /**
  137. * 如果key已存在,将替换原值,并返回原来key所对应的值;如果不存在,则返回 null(注,如果
  138. * 新增key已存在,且为null,返回时也会为null,value为null并不代表key不存在)
  139. */
  140. public Object put(Object key, Object value) {
  141. //插入根节点时不需要调整颜色
  142. Entry t = root;
  143. if (t == null) {
  144. incrementSize();
  145. root = new Entry(key, value, null);
  146. return null;
  147. }
  148. while (true) {
  149. int cmp = compare(key, t.key);
  150. if (cmp == 0) {
  151. return t.setValue(value);
  152. } else if (cmp < 0) {
  153. if (t.left != null) {
  154. t = t.left;
  155. } else {
  156. incrementSize();
  157. t.left = new Entry(key, value, t);
  158. //需要调整颜色
  159. fixAfterInsertion(t.left);
  160. return null;
  161. }
  162. } else { // cmp > 0
  163. if (t.right != null) {
  164. t = t.right;
  165. } else {
  166. incrementSize();
  167. t.right = new Entry(key, value, t);
  168. //需要调整颜色
  169. fixAfterInsertion(t.right);
  170. return null;
  171. }
  172. }
  173. }
  174. }
  175. //从map中删除指定的key节点,并返回value,如果不存在或value本身就是null时,返回null
  176. public Object remove(Object key) {
  177. Entry p = getEntry(key);
  178. if (p == null)
  179. return null;
  180. Object oldValue = p.value;
  181. deleteEntry(p);
  182. return oldValue;
  183. }
  184. public void clear() {
  185. modCount++;
  186. size = 0;
  187. root = null;
  188. }
  189. public Object clone() {
  190. TreeMap clone = null;
  191. try {
  192. //调整父类的克隆方法
  193. clone = (TreeMap) super.clone();
  194. } catch (CloneNotSupportedException e) {
  195. throw new InternalError();
  196. }
  197. // Put clone into "virgin" state (except for comparator)
  198. clone.root = null;
  199. clone.size = 0;
  200. clone.modCount = 0;
  201. clone.entrySet = null;
  202. //...
  203. return clone;
  204. }
  205. // Views
  206. /**
  207. * key-value(键-值对)视图,即该set视图里是一个个的Entry实体节点
  208. */
  209. private transient volatile Set entrySet = null;
  210. //以下两个字段是从父类AbstractMap拷贝过来的,因为在该类与父类不在一个包中,所以不可见
  211. transient volatile Set keySet = null;//key视图,set视图里是一个个Entry实体节点的key
  212. //value视图,collection视图里是一个个Entry实体节点的value
  213. transient volatile Collection values = null;
  214. public Set keySet() {
  215. if (keySet == null) {
  216. //keySet视图实现
  217. keySet = new AbstractSet() {
  218. public Iterator iterator() {
  219. //只能对key进行迭代
  220. return new KeyIterator();
  221. }
  222. public int size() {
  223. return TreeMap.this.size();
  224. }
  225. //...
  226. };
  227. }
  228. return keySet;
  229. }
  230. //value视图中的value排列的顺序保持不变,实质上还是在entrySet视图上迭代的
  231. public Collection values() {
  232. if (values == null) {
  233. //value视图实现
  234. values = new AbstractCollection() {
  235. public Iterator iterator() {
  236. //只能迭代value
  237. return new ValueIterator();
  238. }
  239. public int size() {
  240. return TreeMap.this.size();
  241. }
  242. //...
  243. };
  244. }
  245. return values;
  246. }
  247. //key-value 视图,即Entry节点视图
  248. public Set entrySet() {
  249. if (entrySet == null) {
  250. entrySet = new AbstractSet() {
  251. public Iterator iterator() {
  252. //对Entry节点迭代
  253. return new EntryIterator();
  254. }
  255. //...
  256. public int size() {
  257. return TreeMap.this.size();
  258. }
  259. };
  260. }
  261. return entrySet;
  262. }
  263. //Entry迭代器
  264. private class EntryIterator implements Iterator {
  265. private int expectedModCount = TreeMap.this.modCount;
  266. private Entry lastReturned = null;//指向最后一次next操作所返回的节点
  267. Entry next;//指向当前next()操作要返回的节点
  268. EntryIterator() {
  269. next = firstEntry();//开始时next指向最左边的节点,即中序遍历序列中的第一个节点
  270. }
  271. // Used by SubMapEntryIterator
  272. EntryIterator(Entry first) {
  273. next = first;
  274. }
  275. public boolean hasNext() {
  276. //如果next没有指向null,则表示当前next指向的节点还有
  277. return next != null;
  278. }
  279. //KeyIterator与ValueIterator两迭代器的next()方法实现都是调整此方法来实现的
  280. final Entry nextEntry() {
  281. if (next == null)
  282. throw new NoSuchElementException();
  283. if (modCount != expectedModCount)
  284. throw new ConcurrentModificationException();
  285. lastReturned = next;//先取
  286. next = successor(next);//next再下移
  287. return lastReturned;
  288. }
  289. public Object next() {
  290. //对Entry进行迭代
  291. return nextEntry();
  292. }
  293. public void remove() {
  294. if (lastReturned == null)
  295. throw new IllegalStateException();
  296. if (modCount != expectedModCount)
  297. throw new ConcurrentModificationException();
  298. //如果删除的节点左右子树都存在,则删除后next指针需后退到lastReturned的位置,
  299. //具体为什么,请参考二叉搜索树的实现 BinSearchTree.java 相应方法
  300. if (lastReturned.left != null && lastReturned.right != null)
  301. next = lastReturned;
  302. deleteEntry(lastReturned);
  303. expectedModCount++;
  304. lastReturned = null;
  305. }
  306. }
  307. //KeyIterator是在EntryIterator的基础上只对key进行迭代罢了
  308. private class KeyIterator extends EntryIterator {
  309. public Object next() {
  310. return nextEntry().key;
  311. }
  312. }
  313. //ValueIterator是在EntryIterator的基础上只对value进行迭代罢了
  314. private class ValueIterator extends EntryIterator {
  315. public Object next() {
  316. return nextEntry().value;
  317. }
  318. }
  319. //在这里决定是使用 Comparator 还 Comparable 比较器
  320. private int compare(Object k1, Object k2) {
  321. return (comparator == null ? ((Comparable) k1).compareTo(k2) : comparator
  322. .compare(k1, k2));
  323. }
  324. private static boolean valEquals(Object o1, Object o2) {
  325. return (o1 == null ? o2 == null : o1.equals(o2));
  326. }
  327. private static final boolean RED = false;//false代表红
  328. private static final boolean BLACK = true;//true代表黑
  329. /**
  330. * 树中的节点结构体实现,实现了Map.Entry接口,它是双向的,即可以从子找到父,也可从
  331. * 父到子节点
  332. */
  333. static class Entry implements Map.Entry {
  334. Object key;//数据域key
  335. Object value;//数据域value
  336. Entry left = null;//左指针
  337. Entry right = null;//右指针
  338. Entry parent;//父指针
  339. boolean color = BLACK;//节点着色,相当于平衡二叉排序树中的平衡因子
  340. Entry(Object key, Object value, Entry parent) {
  341. this.key = key;
  342. this.value = value;
  343. this.parent = parent;
  344. }
  345. public Object getKey() {
  346. return key;
  347. }
  348. public Object getValue() {
  349. return value;
  350. }
  351. public Object setValue(Object value) {
  352. Object oldValue = this.value;
  353. this.value = value;
  354. return oldValue;
  355. }
  356. //...
  357. public String toString() {
  358. return key + "=" + value;
  359. }
  360. }
  361. //取树中最左边的节点,即key最小的节点
  362. private Entry firstEntry() {
  363. Entry p = root;
  364. if (p != null)
  365. while (p.left != null)
  366. p = p.left;
  367. return p;
  368. }
  369. //取树中最右边的节点,即key最大的节点
  370. private Entry lastEntry() {
  371. Entry p = root;
  372. if (p != null)
  373. while (p.right != null)
  374. p = p.right;
  375. return p;
  376. }
  377. //查找某节点的中序遍历的直接后继节点,具体请参见BinSearchTree.java 相应方法
  378. private Entry successor(Entry t) {
  379. if (t == null)
  380. return null;
  381. else if (t.right != null) {
  382. Entry p = t.right;
  383. while (p.left != null)
  384. p = p.left;
  385. return p;
  386. } else {
  387. Entry p = t.parent;
  388. Entry ch = t;
  389. while (p != null && ch == p.right) {
  390. ch = p;
  391. p = p.parent;
  392. }
  393. return p;
  394. }
  395. }
  396. //平衡操作
  397. private static boolean colorOf(Entry p) {
  398. //注,如果为null,则返回为黑色,即如果求某个节点的子节点颜色,但子节点不存在时也会返回黑色
  399. return (p == null ? BLACK : p.color);
  400. }
  401. private static Entry parentOf(Entry p) {
  402. return (p == null ? null : p.parent);
  403. }
  404. private static void setColor(Entry p, boolean c) {
  405. if (p != null)
  406. p.color = c;
  407. }
  408. private static Entry leftOf(Entry p) {
  409. return (p == null) ? null : p.left;
  410. }
  411. private static Entry rightOf(Entry p) {
  412. return (p == null) ? null : p.right;
  413. }
  414. //左旋,具体请参见AVLTree.java相应方法
  415. private void rotateLeft(Entry p) {
  416. Entry r = p.right;
  417. p.right = r.left;
  418. if (r.left != null)
  419. r.left.parent = p;
  420. r.parent = p.parent;
  421. if (p.parent == null)
  422. root = r;
  423. else if (p.parent.left == p)
  424. p.parent.left = r;
  425. else
  426. p.parent.right = r;
  427. r.left = p;
  428. p.parent = r;
  429. }
  430. //右旋,具体请参见AVLTree.java相应方法
  431. private void rotateRight(Entry p) {
  432. Entry l = p.left;
  433. p.left = l.right;
  434. if (l.right != null)
  435. l.right.parent = p;
  436. l.parent = p.parent;
  437. if (p.parent == null)
  438. root = l;
  439. else if (p.parent.right == p)
  440. p.parent.right = l;
  441. else
  442. p.parent.left = l;
  443. l.right = p;
  444. p.parent = l;
  445. }
  446. /** From CLR **/
  447. private void fixAfterInsertion(Entry x) {
  448. //插入的节点为红色
  449. x.color = RED;
  450. /*
  451. * 添加节点时,因为在上面将新增节点设置成了红色,所以添加后是不会打破 Path规则 的,但是
  452. * 有可能会打破 Red规则,又打破 Red规则 的前提是父节点是红色的才可能,所以这里的循环条
  453. * 件就是父节点必须是红色的才需调整
  454. *
  455. * 1、如果x为根,则不需要重新染色与旋转,因为最后会将根再次染成BLACK
  456. * 2、如果x的父节点color为黑色,也没必要进行重排了,因为red规则没有被破坏
  457. * 如果上面两个条件不满足,则一直循环,这里x != null 条件也是不可少的,传递进来的值
  458. * 与循环终止时都能可能为null
  459. */
  460. while (x != null && x != root && x.parent.color == RED) {
  461. //一、x的父节点处于左子节点时
  462. if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
  463. //y指向x的右叔,注,有可能为NULL
  464. Entry y = rightOf(parentOf(parentOf(x)));
  465. //如果y为红色
  466. if (colorOf(y) == RED) {//如果条件成立,则y不能可为空
  467. /*
  468. * 情况1:colorOf(y) == RED
  469. *
  470. * 此情况下y不可能为null,因为 colorOf(null) == BLACK,所以此情况
  471. * 下右叔一定存在,既然右叔是红色,所以爷爷节点50只能是黑色了,否则打破
  472. * 了Red规则了。30也肯定是红色了,因为进行while循环前提条件就是父节点
  473. * 一定是红色的
  474. *                         着色
  475. *           .              →              .
  476. *           .                             .
  477. *           50B                      x → 50R
  478. *           /\                            /\
  479. *        30R  90R ← y(右叔)             30B  90B ← y
  480. *           \                            \
  481. *      x → 40R                          40R
  482. *
  483. * 此情况下不需要旋转,完成着色后继续循环
  484. */
  485. //将x节点的父节点的着黑
  486. setColor(parentOf(x), BLACK);
  487. //将x的右叔的着黑
  488. setColor(y, BLACK);
  489. //将x的爷爷着红
  490. setColor(parentOf(parentOf(x)), RED);
  491. /*
  492. * 完成操作后,我们发现x向上移动了两层,因此循环的最大次数是树的高度的一
  493. * 半,这也就是TreeMap中的put方法的最大执行时间为 O(logn) 原因所在了
  494. */
  495. x = parentOf(parentOf(x));//再将x指向爷爷
  496. }//如果y为黑色
  497. else {
  498. if (x == rightOf(parentOf(x))) {
  499. /*
  500. * 情况2:colorOf(y) == BLACK,且x为父的右子节点
  501. *
  502. * 此情况下,y一定是null,为什么?因为插入的节点40的父节点30为红色
  503. * (又为什么?因为进行while循环的前提就是父为红色啊),所以30的父
  504. * 节点只能为黑色了(又为什么?因为如果是红色的话,早就打破了Red规则
  505. * 了),现进入到此分支时前提是y必须是黑色的,如果y真的存在,则Path
  506. * 规则又将被打破,所以此情况下的y一定是null,这样才满足Path规则
  507. *
  508. * ====实质上此种情况就是将问题2转换成转换成问题3来操作====
  509. *
  510. *                   绕30左旋
  511. *        .            →             .
  512. *        .                          .
  513. *       50B                        50B
  514. *        /                          /
  515. *      30R  (Y为NULL)             40R
  516. *        \                         /
  517. *   x → 40R                   x → 30R
  518. */
  519. x = parentOf(x);
  520. rotateLeft(x);
  521. }
  522. /*
  523. * 情况3:colorOf(y) == BLACK,且x为父的左子节点
  524. *
  525. * 如果x为父的右子节点,经过上面情况2的处理,已经将其转换成情况3了,此种
  526. * 情况下的y也一定为null,与第2种情况道理是一样的
  527. *
  528. *                    着色               绕50右旋
  529. *        .            →         .       →       .
  530. *        .                      .               .
  531. *       50B                    50R            40B
  532. *        /                      /               /\
  533. *      40R  (Y为NULL)          40B        x → 30R 50R
  534. *       /                      /
  535. * x → 30R                 x → 30R
  536. *
  537. * 处理后,下次循环自动会终止,因为此情况处理后x的父节点总是黑色的,所以
  538. * 循环一定会终止于下次
  539. */
  540. setColor(parentOf(x), BLACK);//x的父着黑
  541. setColor(parentOf(parentOf(x)), RED);//x的爷着红
  542. if (parentOf(parentOf(x)) != null)
  543. rotateRight(parentOf(parentOf(x)));//绕爷爷右旋
  544. }
  545. }//二、x的父节点处于右子节点时,与第一种对称
  546. else {
  547. //x的左叔
  548. Entry y = leftOf(parentOf(parentOf(x)));
  549. //如果左叔为红色
  550. if (colorOf(y) == RED) {
  551. /*
  552. * 情况1:colorOf(y) == RED,即左叔为红色
  553. *
  554. * 此情况下y不可能为null,因为 colorOf(null) == BLACK,所以此情况
  555. * 下左叔一定存在,既然左叔是红色,所以爷爷节点50只能是黑色了,否则打破
  556. * 了Red规则了。90也肯定是红色了,因为进行while循环前提条件就是父节点
  557. * 一定是红色的
  558. *                         着色
  559. *           .              →              .
  560. *           .                             .
  561. *           50B                      x → 50R
  562. *           /\                            /\
  563. * y(左叔)→30R  90R                      30B 90B ← y
  564. *              \                             \
  565. *          x → 100R                          100R
  566. *
  567. * 此情况下不需要旋转,完成着色后继续循环
  568. */
  569. setColor(parentOf(x), BLACK);
  570. setColor(y, BLACK);
  571. setColor(parentOf(parentOf(x)), RED);
  572. /*
  573. * 完成操作后,我们发现x向上移动了两层,因此循环的最大次数是树的高度的一
  574. * 半,这也就是TreeMap中的put方法的最大执行时间为 O(logn) 原因所在了
  575. */
  576. x = parentOf(parentOf(x));//再将x指向爷爷
  577. }//如果y为黑色
  578. else {
  579. if (x == leftOf(parentOf(x))) {
  580. /*
  581. * 情况2:colorOf(y) == BLACK(左叔为黑),且x为父的左子节点
  582. *
  583. * 此情况下,y一定是null,为什么?因为插入的节点60的父节点90为红色
  584. * ,所以90的父节点只能为黑色了,现进入到此分支时前提是y必须是黑色的
  585. * ,如果y真的存在,则Path规则又将被打破,所以此情况下的y一定是null
  586. * ,这样才满足Path规则
  587. *
  588. * ====实质上此种情况就是将问题2转换成转换成问题3来操作====
  589. *
  590. *                   绕90右旋
  591. *          .            →             .
  592. *          .                          .
  593. *          50B                        50B
  594. *           \                          \
  595. *(Y为NULL)  90R                        60R
  596. *           /                           \
  597. *      x → 60R                      x → 90R
  598. */
  599. x = parentOf(x);
  600. rotateRight(x);
  601. }
  602. /*
  603. * 情况3:colorOf(y) == BLACK,且x为父的右子节点
  604. *
  605. * 如果x为父的左子节点,经过上面情况2的处理,已经将其转换成情况3了,此种
  606. * 情况下的y也一定为null,与第2种情况道理是一样的
  607. *
  608. *                    着色               绕50左旋
  609. *         .            →         .       →       .
  610. *         .                      .               .
  611. *        50B                    50R            90B
  612. *         \                      \               /\
  613. *(Y为NULL) 90R                   90B       x → 50R 95R
  614. *           \                     \
  615. *       x → 95R               x → 95R
  616. *
  617. * 处理后,下次循环自动会终止,因为此情况处理后x的父节点总是黑色的,所以
  618. * 循环一定会终止于下次
  619. */
  620. setColor(parentOf(x), BLACK);//x的父着黑
  621. setColor(parentOf(parentOf(x)), RED);//x的爷着红
  622. if (parentOf(parentOf(x)) != null)
  623. rotateLeft(parentOf(parentOf(x)));//绕爷爷左旋
  624. }
  625. }
  626. }
  627. root.color = BLACK;//不管怎样调整,最后根节点都要着黑
  628. }
  629. //删除节点p,然后重新调整
  630. private void deleteEntry(Entry p) {
  631. decrementSize();
  632. /*
  633. * 如果删除的节点p有左右子树时,将问题转换成删除叶子节点或只有一个子节点的节点问题,具体
  634. * 过程:使用中序遍历直接后s继的数据域值(key与value)拷贝到p的相应数据域值,然后将p指
  635. * 向直接后继s,这样待删除的节点就变成了s,问题已转换成删除叶节点或只有一个子节点的问题了
  636. */
  637. if (p.left != null && p.right != null) {
  638. Entry s = successor(p);
  639. p.key = s.key;
  640. p.value = s.value;
  641. p = s;
  642. }
  643. //replacement用来替换即将被删除节点p
  644. Entry replacement = (p.left != null ? p.left : p.right);
  645. //如果待删除的元素有子节点(如果有,则也有且仅有一个子节点)
  646. if (replacement != null) {
  647. // 重新设置替换节点的父
  648. replacement.parent = p.parent;
  649. //如果待删除节点的为根节点
  650. if (p.parent == null)
  651. root = replacement;//则替换元素将成为根
  652. else if (p == p.parent.left)
  653. //否则如果待删除节点为左节点,则使待删除节点的父的左指针指向替换节点
  654. p.parent.left = replacement;
  655. else
  656. //否则如果待删除节点为右节点,则使待删除节点的父的右指针指向替换节点
  657. p.parent.right = replacement;
  658. // 解除p与其他节点的关系
  659. p.left = p.right = p.parent = null;
  660. /*
  661. * 因为被删除的节点只有两种节点: 叶子节点、只有一个子节点的节点
  662. *
  663. * 如果删除的是只有一个子节点的节点时,根据路径规则,被删除节点一定是黑色的,而子节点
  664. * 一定是红色的,这时删除操作过程就是删除了一个黑红节点而在删除位置上又放置了一个红色
  665. * 节点,因此,删除一个有一个子节点的节点时,Red与Path规则都有可能打破
  666. */
  667. if (p.color == BLACK)//???这里的条件好像是多余的,因为p一定是黑,难道另有玄机?
  668. //删除后从替换节点replacement位置向根方向调整
  669. fixAfterDeletion(replacement);
  670. } else if (p.parent == null) { // 如果待删除节点为根,则置root为null
  671. root = null;
  672. } else { // 如果删除的是叶子节点
  673. /*
  674. * 如果删除的是叶子节点,不管该叶子节点是红还是黑,则 Red规则 在删除后不可能被打破,
  675. * 所以此情况下只有可能打破 Path规则 ,但打破的前提是被删除的节点是黑色的,因为只有
  676. * 黑色节点才影响Path路径规则,所以调整的前提是 p.color == BLACK,即被删除的叶
  677. * 节点是黑色的
  678. */
  679. if (p.color == BLACK)
  680. //删除前从即将被删除节点p位置向根方向调整
  681. fixAfterDeletion(p);
  682. //???此条件好像多余,因为如果不成立,则走上面那个分支了,难道另藏玄机
  683. if (p.parent != null) {
  684. if (p == p.parent.left)
  685. p.parent.left = null;
  686. else if (p == p.parent.right)
  687. p.parent.right = null;
  688. p.parent = null;//解除p与其他节点的关系
  689. }
  690. }
  691. }
  692. //删除节点后调整
  693. private void fixAfterDeletion(Entry x) {
  694. //直循环到根节点或红色止
  695. while (x != root && colorOf(x) == BLACK) {
  696. //x为左子节点
  697. if (x == leftOf(parentOf(x))) {
  698. //x的同胞
  699. Entry sib = rightOf(parentOf(x));//有可能为null
  700. if (colorOf(sib) == RED) {//同胞不可能为null
  701. /*
  702. * 情况1:colorOf(sib) == RED,即右叔存在且为红
  703. *              通过执行上面deleteEntry后,x、p均指向后继65
  704. *        p → 60B             →           65B
  705. *            /  \                        /  \
  706. *          50B   70B                   50B   70B
  707. *          /\    /  \                  /\    /  \
  708. *       45B 55B 65B 80R             45B 55B 65B 80R ← sib
  709. *                   / \                     ↑   /  \
  710. *                 75B 87B                 x、p 75B 87B
  711. *  着色                         绕70左旋
  712. *   →        65B               →           65B
  713. *            /  \                          /  \
  714. *          50B   70R                     50B   80B
  715. *          /\    /  \                    /\    / \
  716. *       45B 55B 65B 80B ← sib         45B 55B 70R 87B
  717. *                ↑   / \                      /  \
  718. *              x、p 75B 87B            x、p → 65B 75B ← sib
  719. *  x现有一个新的同胞节点,该节点为黑,现将情况1转向其他3种情况
  720. */
  721. setColor(sib, BLACK);//置同胞为黑
  722. setColor(parentOf(x), RED);//置父为红
  723. rotateLeft(parentOf(x));//左旋
  724. sib = rightOf(parentOf(x));//再处理同胞节点
  725. }
  726. if (colorOf(leftOf(sib)) == BLACK && colorOf(rightOf(sib)) == BLACK) {
  727. /*
  728. * 情况2:
  729. * colorOf(leftOf(sib))==BLACK && colorOf(rightOf(sib))==BLACK
  730. * 即同胞不存在或同胞存在时为黑且没有子节点的情况
  731. *
  732. * 现接着上面情况1结束后的那棵树处理
  733. * 着色                       再将x指向父(70R)继续处理
  734. *  →      65B                   →           ...
  735. *         /  \
  736. *       50B   80B
  737. *       /\     / \
  738. *     45B 55B 70R 87B
  739. *             / \
  740. *     x、p → 65B 75R ← sib
  741. *
  742. * 处理完后,x为红,因此结束循环,然后设置x的颜色为黑,并从此返回
  743. * deleteEntry方法,此时p所指向的节点已被从其父节点解除链接
  744. */
  745. setColor(sib, RED);
  746. x = parentOf(x);
  747. } else {
  748. if (colorOf(rightOf(sib)) == BLACK) {
  749. /*
  750. * 情况3:经过情况2后,此时同胞节点左子节点必为红
  751. *
  752. * 假设在开始while循环之前有如下树:
  753. *  →      65B
  754. *         /  \
  755. *       50B   80R
  756. *      / \    /  \
  757. *    45B 55B 70B  90B
  758. *            / \   / \
  759. *     x → 65B 75B 85R 95B
  760. *             ↗  / \
  761. *          sib  82B 87B
  762. *
  763. * 情况2被应用,因此将75的颜色设置为红,并令 x = parentOf(x)后第
  764. * 一遍循环结束。第二遍循环开始时,会应用情况3,此时同胞节点为90,树
  765. * 如下图:
  766. * 第一次循环完                  着色
  767. *    →    65B                →          65B
  768. *        /   \                          /  \
  769. *      50B    80R                    50B    80R
  770. *     / \     /  \                   / \    /  \
  771. *   45B 55B 70B   90B ← sib       45B 55B 70B   90R ← sib
  772. *         ↗/ \    / \                  ↗/ \     / \
  773. *       x 65B 75R 85R 95B             x 65B 75R 85B 95B
  774. *                 / \                           / \
  775. *               82B 87B                       82B 87B
  776. *
  777. * 绕90右旋后并修改sib指向           进行下一步循环,应用情况4
  778. *    →          65B                      → ...
  779. *              /   \
  780. *            50B    80R
  781. *           / \     /  \
  782. *         45B 55B 70B   85B ← sib
  783. *               ↗/ \    / \
  784. *             x 65B 75R 82B 90R
  785. *                           / \
  786. *                         87B 95B
  787. *
  788. * 一旦情况3被应用,则同胞节点的右子节点将设置为 RED,因此情况4在情况
  789. * 3之后应用,为了不在下一次循环中应用情况4,直接将情况4的代码放在了
  790. * 情况3的后面
  791. */
  792. setColor(leftOf(sib), BLACK);
  793. setColor(sib, RED);
  794. rotateRight(sib);
  795. sib = rightOf(parentOf(x));
  796. }
  797. /*
  798. * 情况4:经过情况3后剩下的情况4,此时同胞节点的右子节点是红
  799. *
  800. * 接着第3种情况处理:
  801. *
  802. *   着色                    绕80左旋
  803. *    →       65B            →              65B
  804. *           /   \                          /  \
  805. *         50B    80B                     50B   85R ← sib
  806. *        / \     /  \                   / \    /  \
  807. *      45B 55B 70B   85R ← sib        45B 55B 80B 90B
  808. *            ↗/ \    / \                     / \   \
  809. *          x 65B 75R 82B 90B            x → 70B 87B 95B
  810. *                        / \                 /
  811. *                      87B 95B         p → 65B
  812. *
  813. * 循环结束后返回到 deleteEntry 方法,删除65节点即完成删除操作过程
  814. */
  815. setColor(sib, colorOf(parentOf(x)));
  816. setColor(parentOf(x), BLACK);
  817. setColor(rightOf(sib), BLACK);
  818. rotateLeft(parentOf(x));
  819. //情况3与4被应用后,x将被设置为根节点,同时,这也是循环的最后一次
  820. x = root;
  821. }
  822. } else { // 与上面对称
  823. Entry sib = leftOf(parentOf(x));
  824. if (colorOf(sib) == RED) {
  825. setColor(sib, BLACK);
  826. setColor(parentOf(x), RED);
  827. rotateRight(parentOf(x));
  828. sib = leftOf(parentOf(x));
  829. }
  830. if (colorOf(rightOf(sib)) == BLACK && colorOf(leftOf(sib)) == BLACK) {
  831. setColor(sib, RED);
  832. x = parentOf(x);
  833. } else {
  834. if (colorOf(leftOf(sib)) == BLACK) {
  835. setColor(rightOf(sib), BLACK);
  836. setColor(sib, RED);
  837. rotateLeft(sib);
  838. sib = leftOf(parentOf(x));
  839. }
  840. setColor(sib, colorOf(parentOf(x)));
  841. setColor(parentOf(x), BLACK);
  842. setColor(leftOf(sib), BLACK);
  843. rotateRight(parentOf(x));
  844. x = root;
  845. }
  846. }
  847. }
  848. //退出循环时x为根或为红色,直接将其值为黑色即可
  849. setColor(x, BLACK);
  850. }
  851. }

[转载] RED-BLACK(红黑)树的实现TreeMap源码阅读的更多相关文章

  1. [数据结构与算法]RED-BLACK(红黑)树的实现TreeMap源码阅读

    声明:原创作品,转载时请注明文章来自SAP师太技术博客( 博/客/园www.cnblogs.com):www.cnblogs.com/jiangzhengjun,并以超链接形式标明文章原始出处,否则将 ...

  2. 结合java.util.TreeMap源码理解红黑树

    前言 本篇将结合JDK1.6的TreeMap源码,来一起探索红-黑树的奥秘.红黑树是解决二叉搜索树的非平衡问题. 当插入(或者删除)一个新节点时,为了使树保持平衡,必须遵循一定的规则,这个规则就是红- ...

  3. Java数据结构和算法 - TreeMap源码理解红黑树

    前言 本篇将结合JDK1.6的TreeMap源码,来一起探索红-黑树的奥秘.红黑树是解决二叉搜索树的非平衡问题. 当插入(或者删除)一个新节点时,为了使树保持平衡,必须遵循一定的规则,这个规则就是红- ...

  4. Java - TreeMap源码解析 + 红黑树

    Java提高篇(二七)-----TreeMap TreeMap的实现是红黑树算法的实现,所以要了解TreeMap就必须对红黑树有一定的了解,其实这篇博文的名字叫做:根据红黑树的算法来分析TreeMap ...

  5. java集合树状结构及源码

    java集合树状结构及源码 最近一直想看一下java集合的源码,毕竟平时用的比较多,但总是感觉是跟着习惯new出来一个对象,比如ArrayList,HashMap等等,所以就简单的看了一下,了解了一下 ...

  6. 运行OpenGL红宝书第9版源码时Visual Studio提示“无法启动程序...ALL_BUILD。拒绝访问“的问题的解决办法

    问题描述: OpenGL红宝书第9版源码采用CMake编译后,用相应的Visual Studio(如VS2012)打开“vermilion9.sln”解决方案,并运行时Visual Studio提示“ ...

  7. 死磕 java集合之TreeMap源码分析(三)- 内含红黑树分析全过程

    欢迎关注我的公众号"彤哥读源码",查看更多源码系列文章, 与彤哥一起畅游源码的海洋. 删除元素 删除元素本身比较简单,就是采用二叉树的删除规则. (1)如果删除的位置有两个叶子节点 ...

  8. 死磕 java集合之TreeMap源码分析(二)- 内含红黑树分析全过程

    欢迎关注我的公众号"彤哥读源码",查看更多源码系列文章, 与彤哥一起畅游源码的海洋. 插入元素 插入元素,如果元素在树中存在,则替换value:如果元素不存在,则插入到对应的位置, ...

  9. 死磕 java集合之TreeMap源码分析(一)- 内含红黑树分析全过程

    欢迎关注我的公众号"彤哥读源码",查看更多源码系列文章, 与彤哥一起畅游源码的海洋. 简介 TreeMap使用红黑树存储元素,可以保证元素按key值的大小进行遍历. 继承体系 Tr ...

随机推荐

  1. JAVA提高二:枚举

    JDK5.0中有一个非常有用的特性:枚举,这个特性以前在C语言中出现过,后来JDK出现后,开始觉得没有必要,但随着使用JAVA语言的人数增多,发现大家对枚举的需求非常大,于是又加入了此特性,下面我们来 ...

  2. 坑中速记整理! 使用 kotlin 写第一个 ReactNative Android 模块

    Kotlin 和 Swift, 两大新宠! 借 ReactNative 熟悉下 kotlin 的用法,不料掉坑里面了.昨晚花了大半夜,趁这会儿思路清晰,把涉及到的一些关键信息,迅速整理下. 最佳的使用 ...

  3. Java高新技术 JavaBean内省

     Java高新技术  JavaBean内省 知识概要:                 (1)了解JavaBean内省                 (2)JavaBean的简单内省操作     ...

  4. 客户机中PLSQL DEV访问虚拟机中的ORCLE11g,错误百出!

    客户机中PLSQL DEV访问虚拟机中的ORCLE11g,错误百出! 创建时间: 2017/10/14 18:44 作者: CNSIMO 标签: ORACLE 忙了一下午,只有两个字形容:麻烦!   ...

  5. riot.js教程【一】简介

    Riotjs简介 Riotjs是一款简单的.优雅的.组件化UI前端开发框架: 他支持自定义标签(custom tags),拥有令人愉悦的语法,优雅的API和非常小的体积: 为什么需要一个新的界面库 前 ...

  6. Android使用RxJava+Retrofit2+Okhttp+MVP练习的APP

    Android使用RxJava+Retrofit2+Okhttp+MVP练习的APP 项目截图     这是我的目录结构 五步使用RxJava+Retrofit2+Okhttp+RxCache 第一步 ...

  7. 关于KVO导读

    入门篇 KVO是什么? Key-value observing is a mechanism that allows objects to be notified of changes to spec ...

  8. faster-rcnn中ROI_POOIING层的解读

    在没有出现sppnet之前,RCNN使用corp和warp来对图片进行大小调整,这种操作会造成图片信息失真和信息丢失.sppnet这个模型推出来之后(关于这个网络的描述,可以看看之前写的一篇理解:ht ...

  9. LINUX 配置默认程序

    update-alternatives 命令用于配置默认程序,版本切换 1.display 命令,查看命令链接信息 update-alternatives --display name 2.insta ...

  10. windows消息简单应用实例

    //基本定义 internal class MyMessager : IMessageFilter { public bool PreFilterMessage(ref Message m) { // ...