红黑树-TreeMap

最新推荐文章于 2022-12-23 08:56:38 发布
最新推荐文章于 2022-12-23 08:56:38 发布
阅读量1.2k 收藏 1
点赞数 2
分类专栏： Java 数据结构与算法 数据结构与算法 文章标签： java 数据结构 二叉树 TreeMap 红黑树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/junbin1011/article/details/53410219
版权

1.原理

排序二叉树

排序二叉树是一种特殊结构的二叉树，可以非常方便地对树中所有节点进行排序和检索。

排序二叉树要么是一棵空二叉树，要么是具有下列性质的二叉树：

  • 若它的左子树不空，则左子树上所有节点的值均小于它的根节点的值；
  • 若它的右子树不空，则右子树上所有节点的值均大于它的根节点的值；
  • 它的左、右子树也分别为排序二叉树。
平衡二叉树
平衡二叉树（Balanced Binary Tree）是二叉查找树的一个进化体，也是第一个引入平衡概念的二叉树。1962年，G.M. Adelson-Velsky 和 E.M. Landis发明了这棵树，所以它又叫AVL树。
平衡二叉树要求对于每一个节点来说，它的左右子树的高度之差不能超过1，如果插入或者删除一个节点使得高度之差大于1，就要进行节点之间的旋转，将二叉树重新维持在一个平衡状态。
这个方案很好的解决了二叉查找树退化成链表的问题，把插入，查找，删除的时间复杂度最好情况和最坏情况都维持在O(logN)。但是频繁旋转会使插入和删除牺牲掉O(logN)左右的时间。

红黑树

 红黑树顾名思义就是节点是红色或者黑色的平衡二叉树，它通过颜色的约束来维持着二叉树的平衡。对于一棵有效的红黑树二叉树而言我们必须增加如下规则：

       1、每个节点都只能是红色或者黑色

       2、根节点是黑色

       3、每个叶节点（NIL节点，空节点）是黑色的。

       4、如果一个结点是红的，则它两个子节点都是黑的。也就是说在一条路径上不能出现相邻的两个红色结点。

       5、从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。



排序二叉树的深度直接影响了检索的性能，正如前面指出，当插入节点本身就是由小到大排列时，排序二叉树将变成一个链表，这种排序二叉树的检索性能最低：N 个节点的二叉树深度就是 N-1。

红黑树通过上面这种限制来保证它大致是平衡的——因为红黑树的高度不会无限增高，这样保证红黑树在最坏情况下都是高效的，不会出现普通排序二叉树的情况。

由于红黑树只是一个特殊的排序二叉树，因此对红黑树上的只读操作与普通排序二叉树上的只读操作完全相同，只是红黑树保持了大致平衡，因此检索性能比排序二叉树要好很多。

但在红黑树上进行插入操作和删除操作会导致树不再符合红黑树的特征，因此插入操作和删除操作都需要进行一定的维护，以保证插入节点、删除节点后的树依然是红黑树。

2.数据结构模型

 static final class Entry<K,V> implements Map.Entry<K,V> {
  K key; 
  V value;
  Entry<K,V> left = null; //左节点
  Entry<K,V> right = null;//右节点
  Entry<K,V> parent;//父节点
  boolean color = BLACK;//颜色

  /**
  * Make a new cell with given key, value, and parent, and with
  * {@code null} child links, and BLACK color.
  */
  Entry(K key, V value, Entry<K,V> parent) {
  this.key = key;
  this.value = value;
  this.parent = parent;
  }

  /**
  * Returns the key.
  *
  * @return the key
  */
  public K getKey() {
  return key;
  }

  /**
  * Returns the value associated with the key.
  *
  * @return the value associated with the key
  */
  public V getValue() {
  return value;
  }

  /**
  * Replaces the value currently associated with the key with the given
  * value.
  *
  * @return the value associated with the key before this method was
  * called
  */
  public V setValue(V value) {
  V oldValue = this.value;
  this.value = value;
  return oldValue;
  }

  public boolean equals(Object o) {
  if (!(o instanceof Map.Entry))
  return false;
  Map.Entry<?,?> e = (Map.Entry<?,?>)o;

  return valEquals(key,e.getKey()) && valEquals(value,e.getValue());
  }

  public int hashCode() {
  int keyHash = (key==null ? 0 : key.hashCode());
  int valueHash = (value==null ? 0 : value.hashCode());
  return keyHash ^ valueHash;
  }

  public String toString() {
  return key + "=" + value;
  }
  }

3.Put

  1. 以根节点当前节点开始搜索。
  2. 拿新节点的值和当前节点的值比较。
  3. 如果新节点的值更大，则以当前节点的右子节点作为新的当前节点；如果新节点的值更小，则以当前节点的左子节点作为新的当前节点。
  4. 重复 2、3 两个步骤，直到搜索到合适的叶子节点为止。
  5. 将新节点添加为第 4 步找到的叶子节点的子节点；如果新节点更大，则添加为右子节点；否则添加为左子节点。
  6. 修复红黑树

public V put(K key, V value) {
  Entry<K,V> t = root;
  if (t == null) {
  compare(key, key); // type (and possibly null) check

  root = new Entry<>(key, value, null);
  size = 1;
  modCount++;
  return null;
  }
  int cmp;
  Entry<K,V> parent;
  // split comparator and comparable paths
  Comparator<? super K> cpr = comparator;
  if (cpr != null) {
  do {
  parent = t;
  cmp = cpr.compare(key, t.key);
  if (cmp < 0)
  t = t.left;
  else if (cmp > 0)
  t = t.right;
  else
  return t.setValue(value);
  } while (t != null);
  }
  else {
  if (key == null)
  throw new NullPointerException();
  Comparable<? super K> k = (Comparable<? super K>) key;
  do {
  parent = t;
  cmp = k.compareTo(t.key);
  if (cmp < 0)
  t = t.left;
  else if (cmp > 0)
  t = t.right;
  else
  return t.setValue(value);
  } while (t != null);
  }
  Entry<K,V> e = new Entry<>(key, value, parent);
  if (cmp < 0)
  parent.left = e;
  else
  parent.right = e;
  fixAfterInsertion(e);
  size++;
  modCount++;
  return null;
  }

4.Get

  1. 以根节点当前节点开始搜索。
  2. 拿新节点的值和当前节点的值比较。
  3. 如果新节点的值更大，则以当前节点的右子节点作为新的当前节点；如果新节点的值更小，则以当前节点的左子节点作为新的当前节点。如果相等则返回改Entry
  4. 重复 2、3 两个步骤，直到搜索到合适的叶子节点为止。
final Entry<K,V> getEntry(Object key) {
  // Offload comparator-based version for sake of performance
  if (comparator != null)
  return getEntryUsingComparator(key);
  if (key == null)
  throw new NullPointerException();
  Comparable<? super K> k = (Comparable<? super K>) key;
  Entry<K,V> p = root;
  while (p != null) {
  int cmp = k.compareTo(p.key);
  if (cmp < 0)
  p = p.left;
  else if (cmp > 0)
  p = p.right;
  else
  return p;
  }
  return null;
  }
5.Remove

当程序从排序二叉树中删除一个节点之后，为了让它依然保持为排序二叉树，程序必须对该排序二叉树进行维护。维护可分为如下几种情况：

（1）被删除的节点是叶子节点，则只需将它从其父节点中删除即可。

（2）被删除节点 p 只有左子树，将 p 的左子树 pL 添加成 p 的父节点的左子树即可；被删除节点 p 只有右子树，将 p 的右子树 pR 添加成 p 的父节点的右子树即可。
（3）若被删除节点 p 的左、右子树均非空，找P的替代节点。规则是右分支最左边，或者 左分支最右边的节点
（4）修复红黑树 
public V remove(Object key) {
  Entry<K,V> p = getEntry(key);
  if (p == null)
  return null;

  V oldValue = p.value;
  deleteEntry(p);
  return oldValue;
  }

private void deleteEntry(Entry<K,V> p) {
  modCount++; //修改次数 +1
  size--; //元素个数 -1

  /*
  * 被删除节点的左子树和右子树都不为空，那么就用 p节点的中序后继节点代替 p 节点
  * successor(P)方法为寻找P的替代节点。规则是右分支最左边，或者 左分支最右边的节点
  * ---------------------（1）
  */
  if (p.left != null && p.right != null) {
  Entry<K,V> s = successor(p);
  p.key = s.key;
  p.value = s.value;
  p = s;
  }

  //replacement为替代节点，如果P的左子树存在那么就用左子树替代，否则用右子树替代
  Entry<K,V> replacement = (p.left != null ? p.left : p.right);

  /*
  * 删除节点，分为上面提到的三种情况
  * -----------------------（2）
  */
  //如果替代节点不为空
  if (replacement != null) {
  replacement.parent = p.parent;
  /*
  *replacement来替代P节点
  */
  //若P没有父节点，则跟节点直接变成replacement
  if (p.parent == null)
  root = replacement;
  //如果P为左节点，则用replacement来替代为左节点
  else if (p == p.parent.left)
  p.parent.left = replacement;
  //如果P为右节点，则用replacement来替代为右节点
  else
  p.parent.right = replacement;

  //同时将P节点从这棵树中剔除掉
  p.left = p.right = p.parent = null;

  /*
  * 若P为红色直接删除，红黑树保持平衡
  * 但是若P为黑色，则需要调整红黑树使其保持平衡
  */
  if (p.color == BLACK)
  fixAfterDeletion(replacement);
  } else if (p.parent == null) { //p没有父节点，表示为P根节点，直接删除即可
  root = null;
  } else { //P节点不存在子节点，直接删除即可
  if (p.color == BLACK) //如果P节点的颜色为黑色，对红黑树进行调整
  fixAfterDeletion(p);

  //删除P节点
  if (p.parent != null) {
  if (p == p.parent.left)
  p.parent.left = null;
  else if (p == p.parent.right)
  p.parent.right = null;
  p.parent = null;
  }
  }
  }

6.左旋(rotateLeft())、右旋（rotateRight()）

/** From CLR */
  private void rotateLeft(Entry<K,V> p) {
  if (p != null) {
  Entry<K,V> r = p.right;
  p.right = r.left;
  if (r.left != null)
  r.left.parent = p;
  r.parent = p.parent;
  if (p.parent == null)
  root = r;
  else if (p.parent.left == p)
  p.parent.left = r;
  else
  p.parent.right = r;
  r.left = p;
  p.parent = r;
  }
  }


 
/** From CLR */
  private void rotateRight(Entry<K,V> p) {
  if (p != null) {
  Entry<K,V> l = p.left;
  p.left = l.right;
  if (l.right != null) l.right.parent = p;
  l.parent = p.parent;
  if (p.parent == null)
  root = l;
  else if (p.parent.right == p)
  p.parent.right = l;
  else p.parent.left = l;
  l.right = p;
  p.parent = l;
  }
  }

8.总结

1.Treemap是基于红黑树的数据模式，是一颗排序二叉树。红黑树不追求完全平衡，对比AVL，降低了对旋转的要求，从而提高了性能。
2、TreeMap的查询、插入、删除效率均没有HashMap高(o(logn):o(1))，一般只有要对key排序时才使用TreeMap。但TreeMap的空间利用率要高于HashMap。
3、TreeMap的key不能为null，而HashMap的key可以为null。

参考文献
junbin1011
关注
专栏目录
Android版数据结构与算法(十)：终极之树-红黑树与TreeMap详细解析
qq_16386581的博客
12-20 619
本文目录 一、为什么要创建红黑树这种数据结构 在上篇我们了解了AVL树，既然已经有了AVL这种平衡的二叉排序树，为什么还要有红黑树呢？ AVL树通过定义我们知道要求树中每一个结点的左右子树高度差的绝对值不超过1，其是一颗严格的平衡树，这样构建出来的平衡二叉排序树具有很好的查找性能，但是为了保持其每个结点平衡因子绝对值不超过1的特性在插入或者删除的时候需要的维护成本是很大的，插入或者删除需要大量的...
红黑树与TreeMap详细解析
李利科
02-21 514
一、为什么要创建红黑树这种数据结构 在上篇我们了解了AVL树，既然已经有了AVL这种平衡的二叉排序树，为什么还要有红黑树呢？ AVL树通过定义我们知道要求树中每一个结点的左右子树高度差的绝对值不超过1，其是一颗严格的平衡树，这样构建出来的平衡二叉排序树具有很好的查找性能，但是为了保持其每个结点平衡因子绝对值不超过1的特性在插入或者删除的时候需要的维护成本是很大的，插入或者删除需要大量的平衡度计算，比如上一篇在AVL的插入的时候就需要不断回溯其父节点调整平衡因子的值，数据量小没什么问题，但是实际应用中往往数.
红黑树的添加删除操作
热门推荐
好好学习
07-09 2万+
<br /><br />来自: http://hi.baidu.com/coolinc/blog/item/3aa07f3e162502eb54e723b1.html<br />介绍另一种平衡二叉树：红黑树（Red Black Tree），红黑树由Rudolf Bayer于1972年发明，当时被称为平衡二叉B树（symmetric binary B-trees），1978年被Leonidas J. Guibas 和Robert Sedgewick改成一个比较摩登的名字：红黑树。<br />红黑树和之前所讲的
TreeMap的底层实现(红黑树)
qq_35254085的博客
03-19 312
1、红黑树的基本概念 红黑树，对很多童鞋来说，是既熟悉又陌生。学校中学过，只了解大概；工作中不怎么使用，但面试又是重点。 每次需要查看红黑树内容时都很难以更生动形象的方式来理解其内容。 没错，本文内容就是要解决这个问题，用简单的语言，搭配静图和动图(利用大脑图形记忆方式)，让你对红黑树有更深入的了解和更清晰的记忆，希望小伙伴们再次遇到红黑树的问题不至于头大。 每个节点都只能是红色或者黑色根节点是黑色每个叶节点（NIL节点，空节点）是黑色的。 如果一个结点是红的，则它两个子节点都是黑的。也就是说在一条路径上不
TreeMap 红黑树
我是谁
03-09 298
TreeMap 红黑树
红黑树-基于Java实现的红黑树数据结构.zip
最新发布
03-21
- Java标准库中的`java.util.TreeMap`和`java.util.TreeSet`类底层就是用红黑树实现的。 - 实现红黑树需要定义节点类，包含节点值、颜色、左子节点、右子节点以及父节点等属性，并实现插入、删除、旋转等方法。 6...
TreeMap红黑树解析
xizhuyuan1676的博客
11-05 723
TreeMap小白解析
PHP-TreeMap.zip
08-13
在IT领域，数据结构是编程基础中的重要组成部分，而红黑树作为一种自平衡二叉查找树，具有很多独特的性质和优势。PHP虽然不是通常用于实现这类复杂数据结构的语言，但通过对"PHP-TreeMap.zip"的分析，我们可以看到...
java集合-TreeMap的使用
06-14
TreeMap是一种基于红黑树实现的有序映射（SortedMap）。它实现了NavigableMap接口，可以按照键的自然顺序或自定义排序规则对键值对进行排序和访问。
Map和HashMap
weixin_39996256的博客
05-18 212
Map: key-value映射 ,通过泛型对象的equals方法判断是否重复，key重复则覆盖。 HashMap:核心为Node类，1.8之前为Entry 存储数据过程：核心为产生hash值，该值用来对应数组的存储位置，当同一位置的链表长度为8的时候就会生成红黑树。 取数据过程： 获取key，计算hashcode();,获取hash值。定位数组位置 对应位置的链表中挨个比较key，...
java中treemap和treeset实现红黑树
08-28
主要为大家详细介绍了java中treemap和treeset实现红黑树，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
TreeMap 红黑树 学习
nobaldnolove的博客
08-07 728
对红黑树的研究，为学习ConcurrentHashMap 先打好基础。
红黑树完全解析(基于TreeMap)
gin_yz的博客
03-09 426
红黑树的例子 在线例子网址 https://www.cs.usfca.edu/~galles/visualization/RedBlack.html 内部节点及类定义 Get/Set方法省略 static class RBNode<K extends Comparable<K>, V> { private RBNode parent; private RBNode left; private RBNode right; private boolean color;
TreeMap与红黑树
qx5211258的专栏
07-04 423
TreeMap的实现是红黑树算法的实现，所以要了解TreeMap就必须对红黑树有一定的了解,其实这篇博文的名字叫做：根据红黑树的算法来分析TreeMap的实现，但是为了与Java提高篇系列博文保持一致还是叫做TreeMap比较好。通过这篇博文你可以获得如下知识点：        1、红黑树的基本概念。        2、红黑树增加节点、删除节点的实现过程。        3、红黑
基于TreeMap分析红黑树
Tiffany学习的博客
08-12 212
由于TreeMap底层是由红黑树实现的，所以我们先来了解一下红黑树 本文参考红黑树 红黑树本身是一个二叉查找树，二叉查找树又称为有序二叉树，排序二叉树，是指空树，或者具有如下性质的二叉树： 若任意结点的左子树不空，则左子树上所有结点的值均小于其根节点的值 若任意结点的右子树不空，则右子树上所有结点的值均大于其根节点的值 任意结点的左右子树也分别称为二叉查找树 没有键值相等的结点 红黑树...
红黑树TreeMap使用
ZERO
09-04 346
转载自：http://blog.csdn.net/chenssy/article/details/26668941 TreeMap的实现是红黑树算法的实现。 红黑树简介        红黑树又称红-黑二叉树，它首先是一颗二叉树，它具体二叉树所有的特性。同时红黑树更是一个自平衡的排序二叉树。        一个基本的二叉树都需要满足一个基本性质，即树中的任何节点的值大于它的左子节
【数据结构进阶】红黑树【TreeMap TreeSet底层就是红黑树】
孙宇航的博客
12-23 1409
红黑树【TreeMap TreeSet底层就是红黑树】 概念 红黑树是一种二叉搜索树，但在每个结点上增加一个存储位表示结点的颜色，可能是Red或者Black。通过对任何一条从根到叶子结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出两倍，因而是 接近平衡的。
关于红黑树(R-B tree)原理，看这篇如何
weixin_30922589的博客
07-17 145
学过数据数据结构都知道二叉树的概念，而又有多种比较常见的二叉树类型，比如完全二叉树、满二叉树、二叉搜索树、均衡二叉树、完美二叉树等；今天我们要说的红黑树就是就是一颗非严格均衡的二叉树，均衡二叉树又是在二叉搜索树的基础上增加了自动维持平衡的性质，插入、搜索、删除的效率都比较高。红黑树也是实现TreeMap存储结构的基石。 一. 二叉搜索树 二叉搜索树又叫二叉查找树、二叉排序树，我们先看一下典型的二叉...
java中treemap和treeset实现（红黑树）
abcdef00001111234的博客
08-26 65
TreeMap 的实现就是红黑树数据结构，也就说是一棵自平衡的排序二叉树，这样就可以保证当需要快速检索指定节点。 TreeSet 和 TreeMap 的关系 为了让大家了解 TreeMap 和 TreeSet 之间的关系，下面先看 TreeSet 类的部分源代码： public class TreeSet<E> extends Abstract...
深入理解红黑树：分析Java TreeMap源码
"通过深入分析`java.util.TreeMap`的源码，本文旨在加深读者对红黑树这一经典数据结构的理解。红黑树是一种自平衡二叉查找树，它解决了传统二叉搜索树在某些情况下可能导致的性能问题。文章将基于JDK 1.6的`TreeMap`...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值