TreeMap源码分析解读

TreeMap

平衡二叉树

平衡二叉树(Self-balancing binary search tree)又被称为AVL树(有别于AVL算法),且具有以下性质:它是一棵空树或它的左右两个子树的高度差的绝对值不超过1,并且左右两个子树都是一棵平衡二叉树,同时,平衡二叉树必定是二叉搜索树,反之则不一定。平衡二叉树的常用实现方法有红黑树AVL替罪羊树Treap伸展树等。 最小二叉平衡树的节点的公式如下 F(n)=F(n-1)+F(n-2)+1 这个类似于一个递归的数列,可以参考Fibonacci(斐波那契)数列,1是根节点,F(n-1)是左子树的节点数量,F(n-2)是右子树的节点数量。

我们知道,对于一般的二叉搜索树(Binary Search Tree),其期望高度(即为一棵平衡树时)为log2n,其各操作的时间复杂度(O(log2n))同时也由此而决定。但是,在某些极端的情况下(如在插入的序列是有序的时),二叉搜索树将退化成近似链表或链,此时,其操作的时间复杂度将退化成线性的,即O(n)。我们可以通过随机化建立二叉搜索树来尽量的避免这种情况,但是在进行了多次的操作之后,由于在删除时,我们总是选择将待删除节点的后继代替它本身,这样就会造成总是右边的节点数目减少,以至于树向左偏沉。这同时也会造成树的平衡性受到破坏,提高它的操作的时间复杂度。

平衡二叉搜索树(Balanced Binary Tree)具有以下性质:它是一棵空树或它的左右两个子树的高度差的绝对值不超过1,并且左右两个子树都是一棵平衡二叉树。常用算法有红黑树、AVL、Treap、伸展树等。在平衡二叉搜索树中,我们可以看到,其高度一般都良好地维持在O(log(n)),大大降低了操作的时间复杂度。

  • 红黑树

红黑树(Red Black Tree)是一种自平衡二叉查找树,是在计算机科学中用到的一种数据结构,典型的用途是实现关联数组。它是在1972年由Rudolf Bayer发明的,他称之为”对称二叉B树”,它现代的名字是在 Leo J. Guibas 和 Robert Sedgewick 于1978年写的一篇论文中获得的。它是复杂的,但它的操作有着良好的最坏情况运行时间,并且在实践中是高效的:它可以在O(log n)时间内做查找,插入和删除,这里的n是树中元素的数目。

  • AVL

AVL是最先发明的自平衡二叉查找树算法。在AVL中任何节点的两个儿子子树的高度最大差别为一,所以它也被称为高度平衡树,n个结点的AVL树最大深度约1.44log2n。查找、插入和删除在平均和最坏情况下都是O(log n)。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。

  • Treap

Treap是一棵二叉排序树,它的左子树和右子树分别是一个Treap,和一般的二叉排序树不同的是,Treap纪录一个额外的数据,就是优先级。Treap在以关键码构成二叉排序树的同时,还满足堆的性质(在这里我们假设节点的优先级大于该节点的孩子的优先级)。但是这里要注意的是Treap和二叉堆有一点不同,就是二叉堆必须是完全二叉树,而Treap并不一定是。

  • 伸展树

伸展树(Splay Tree)是一种二叉排序树,它能在O(log n)内完成插入、查找和删除操作。它由Daniel Sleator和Robert Tarjan创造。它的优势在于不需要记录用于平衡树的冗余信息。在伸展树上的一般操作都基于伸展操作。

TreeMap签名

public class TreeMap
   extends AbstractMap
   implements NavigableMap, Cloneable, java.io.Serializable

相比HashMap来说,TreeMap多实现了一个接口NavigableMap,也就是这个接口,决定了TreeMap与HashMap的不同:HashMap的key是无序的,TreeMap的key是有序的。

public interface NavigableMap extends SortedMap

发现NavigableMap继承了SortedMap,再看SortedMap的签名

public interface SortedMap extends Map

SortedMap就像其名字那样,说明这个Map是有序的。这个顺序一般是指由Comparable接口提供的keys的自然序(natural ordering),或者也可以在创建SortedMap实例时,指定一个Comparator来决定。 当我们在用集合视角(collection views,与HashMap一样,也是由entrySet、keySet与values方法提供)来迭代(iterate)一个SortedMap实例时会体现出key的顺序。

  • Comparable一般表示类的自然序,比如定义一个Student类,学号为默认排序
  • Comparator一般表示类在某种场合下的特殊分类,需要定制化排序。比如现在想按照Student类的age来排序

插入SortedMap中的key的类都必须实现Comparable接口(或指定一个comparator),这样才能确定如何比较(通过k1.compareTo(k2)或comparator.compare(k1, k2))两个key,否则,在插入时,会报ClassCastException的异常。 此外,SortedMap中key的顺序性应该与equals方法保持一致。也就是说k1.compareTo(k2)或comparator.compare(k1, k2)为true时,k1.equals(k2)也应该为true。 介绍完了SortedMap,再来回到我们的NavigableMap上面来。 NavigableMap是JDK1.6新增的,在SortedMap的基础上,增加了一些“导航方法”(navigation methods)来返回与搜索目标最近的元素。例如下面这些方法:

  • lowerEntry,返回所有比给定Map.Entry小的元素
  • floorEntry,返回所有比给定Map.Entry小或相等的元素
  • ceilingEntry,返回所有比给定Map.Entry大或相等的元素
  • higherEntry,返回所有比给定Map.Entry大的元素

TreeMap计理念

红黑树(Red–black tree)

TreeMap是基于红黑树结构实现的一种Map,要分析TreeMap的实现首先就要对红黑树有所了解。红黑树是一种自平衡二叉查找树。

二叉查找树
  • 若左子树不为空,则左子树上所有节点的值均小于它的根节点的值;
  • 若右子树不为空,则右子树上所有节点的值均大于它的根节点的值;
  • 左、右子树也分别为二叉查找树;
  • 没有键值相等的节点。

按照二叉查找树存储的数据,对元素的搜索效率是非常高的,比如上图中如果要查找值为48的节点,只需要遍历4个节点就能完成。

用代码实现简单的二叉查找树:

public class BinaryTree {

    // 二叉树的根节点
    public TreeNode rootNode;
    // 记录搜索深度
    public int count;

    /**
     * 利用传入一个数组来建立二叉树
     */
    public BinaryTree(int[] data) {
        for (int i = 0; i < data.length; i++) {
            addNodeToTree(data[i]);
        }
    }

    /**
     * 将指定的值加入到二叉树中适当的节点
     */
    private void addNodeToTree(int value) {
        TreeNode currentNode = rootNode;
        // 建立树根
        if (rootNode == null) {
            rootNode = new TreeNode(value);
            return;
        }

        // 建立二叉树
        while (true) {
            // 新增的value比节点的value小,则在左子树
            if (value < currentNode.value) {
                if (currentNode.leftNode == null) {
                    currentNode.leftNode = new TreeNode(value);
                    return;
                } else {
                    currentNode = currentNode.leftNode;
                }
            } else { // 新增的value比节点的value大,在右子树
                if (currentNode.rightNode == null) {
                    currentNode.rightNode = new TreeNode(value);
                    return;
                } else {
                    currentNode = currentNode.rightNode;
                }
            }
        }
    }

    /**
     * 中序遍历(左子树 -树根- 右子树)
     */
    public void inOrder(TreeNode node) {
        if (node != null) {
            inOrder(node.leftNode);
            System.out.print("[" + node.value + "]");
            inOrder(node.rightNode);
        }
    }

    /**
     * 前序遍历(树根 -左子树- 右子树)
     */
    public void preOrder(TreeNode node) {
        if (node != null) {
            System.out.print("[" + node.value + "]");
            preOrder(node.leftNode);
            preOrder(node.rightNode);
        }
    }

    /**
     * 后序遍历(左子树 -右子树- 树根)
     */
    public void postOrder(TreeNode node) {
        if (node != null) {
            postOrder(node.leftNode);
            postOrder(node.rightNode);
            System.out.print("[" + node.value + "]");
        }
    }

    /**
     * 从二叉树中查找指定value
     */
    public boolean findTree(TreeNode node, int value) {
        if (node == null) {
            System.out.println("共搜索" + count + "次");
            return false;
        } else if (node.value == value) {
            System.out.println("共搜索" + count + "次");
            return true;
        } else if (value < node.value) {
            count++;
            return findTree(node.leftNode, value);
        } else {
            count++;
            return findTree(node.rightNode, value);
        }
    }

    /**
     * 利用中序遍历进行排序
     */
    public void sort() {
        this.inOrder(rootNode);
    }

    class TreeNode {
        int value;
        TreeNode leftNode;
        TreeNode rightNode;

        public TreeNode(int value) {
            this.value = value;
            this.leftNode = null;
            this.rightNode = null;
        }
    }

    public static void main(String[] args) {
        int[] content = { 50, 35, 27, 45, 40, 48, 78, 56, 90 };

        BinaryTree tree = new BinaryTree(content);
        System.out.println("前序遍历:");
        tree.preOrder(tree.rootNode);
        System.out.println("\n中序遍历:");
        tree.inOrder(tree.rootNode);
        System.out.println("\n后序遍历:");
        tree.postOrder(tree.rootNode);

        System.out.println("\n\n开始搜索:");
        boolean isFind = tree.findTree(tree.rootNode, 48);
        System.out.println("是否搜索到" + 48 + ":" + isFind);

        System.out.println("\n进行排序:");
        tree.sort();
    }

}

理论上,一颗平衡的二叉查找树的任意节点平均查找效率为树的高度h,即O(logn)。但是如果二叉查找树失去平衡(元素全在一侧),搜索效率就退化为O(n),因此二叉查找树的平衡是搜索效率的关键所在。而红黑树就是靠红黑规则来维持二叉查找树的平衡性

(一颗失去平衡的二叉树)

红黑树的红黑规则
  • 节点是红色或黑色。
  • 根节点是黑色。
  • 每个叶节点(NIL节点,空节点)是黑色的。
  • 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)
  • 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。

上面的规则前4条都好理解,第5条规则到底是什么情况,下面简单解释下,比如:图中红8到1左边的叶子节点的路径包含两个黑色节点,到6下面的叶子节点的路径也包含两个黑色节点。

但是在添加或删除节点后,红黑树就发生了变化,可能不再满足上面的5个特性,为了保持红黑树的以上特性,就有了三个动作:左旋、右旋、着色。

  • 左旋

对x进行左旋,意味着“将x变成一个左节点”。

  • 右旋

对y进行右旋,意味着”将y变成一个右节点”。

参考:http://www.cnblogs.com/yangecnu/p/introduce-red-black-tree.html

TreeMap属性

// 比较器
private final Comparator comparator;

// 红黑树根节点
private transient Entry root = null;

// 集合元素数量
private transient int size = 0;

// "fail-fast"集合修改记录
private transient int modCount = 0;

Entry是树的节点类,我们来看一下Entry的定义:

static final class Entry implements Map.Entry {
    K key;
    V value;
    // 左孩子节点
    Entry left = null;
    // 右孩子节点
    Entry right = null;
    // 父节点
    Entry parent;
    // 红黑树用来表示节点颜色的属性,默认为黑色
    boolean color = BLACK;

    /**
     * 用key,value和父节点构造一个Entry,默认为黑色
     */
    Entry(K key, V value, Entry parent) {
        this.key = key;
        this.value = value;
        this.parent = parent;
    }

    public K getKey() {
        return key ;
    }

    public V getValue() {
        return value ;
    }

    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;
    }
}   

Entry类理解起来比较简单(因为我们前面看过很多的Entry类了),主要是定义了树的孩子和父亲节点引用,和红黑颜色属性,并对equals和hashCode进行重写,以利于比较是否相等。

TreeMap的构造方法

/**
 * 默认构造方法,comparator为空,代表使用key的自然顺序来维持TreeMap的顺序,这里要求key必须实现Comparable接口
 */
public TreeMap() {
    comparator = null;
}

/**
 * 用指定的比较器构造一个TreeMap
 */
public TreeMap(Comparator comparator) {
    this.comparator = comparator;
}

/**
 * 构造一个指定map的TreeMap,同样比较器comparator为空,使用key的自然顺序排序
 */
public TreeMap(Map m) {
    comparator = null;
    putAll(m);
}

/**
 * 构造一个指定SortedMap的TreeMap,根据SortedMap的比较器来来维持TreeMap的顺序
 */
public TreeMap(SortedMap m) {
    comparator = m.comparator();
    try {
        buildFromSorted(m.size(), m.entrySet().iterator(), null, null);
    } catch (java.io.IOException cannotHappen) {
    } catch (ClassNotFoundException cannotHappen) {
    }
}

从构造方法中可以看出,要创建一个红黑树实现的TreeMap必须要有一个用于比较大小的比较器,因为只有能够比较大小才能实现红黑树的左孩子<树根<右孩子的特点。

红黑树的添加原理及TreeMap的put实现

将一个节点添加到红黑树中,通常需要下面几个步骤:

  • 将红黑树当成一颗二叉查找树,将节点插入。
    这一步比较简单,就跟开始我们自己写的二叉查找树的操作一样,至于为什么可以这样插入,是因为红黑树本身就是一个二叉查找树。
  • 将新插入的节点设置为红色。有没有疑问,为什么新插入的节点一定要是红色的,因为新插入节点为红色,不会违背红黑规则第(5)条,少违背一条就少处理一种情况。
  • 通过旋转和着色,使它恢复平衡,重新变成一颗符合规则的红黑树。

要想知道怎么样进行左旋和右旋,首先就要知道为什么要进行左旋和右旋。我们来对比下红黑树的规则和新插入节点后的情况,看下新插入节点会违背哪些规则。

  1. 节点是红色或黑色。这一点肯定是不会违背的了。
  2. 根节点是黑色。这一点也不会违背了,如果是根节点,只需将根节点插入就好了,因为默认是黑色。
  3. 每个叶节点(NIL节点,空节点)是黑色的。这一点也不会违背的,我们插入的是非空的节点,不会影响空节点。
  4. 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点)。这一点是有可能违背的,我们将新插入的节点都设置成红色,如果其父节点也是红色的话,那就产生冲突了。
  5. 从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。这一点也不会违背,因为我们将新插入的节点都设置成红色。

了解了红黑树左旋和右旋操作,以及新插入节点主要是可能会违背红黑树的规则(4)后,我们来分析下,添加新节点的过程有哪几种情况:

  1. 新插入节点为根节点。这种情况直接将新插入节点设置为根节点即可,无需进行后续的旋转和着色处理。
  2. 新插入节点的父节点是黑色。这种情况直接将新节点插入即可,不会违背规则(4)。
  3. 新插入节点的父节点是红色。这种情况会违背规则(4),而这种情况又分为了以下几种,下面进行图解:

①新插入节点N的父节点P和叔叔节点U都是红色。

方法是:将祖父节点G设置为红色,父节点P和叔叔节点U设置为黑色,这时候就看似平衡了。但是,如果祖父节点G的父节点也是红色,这时候又违背规则(4)了,怎么办,方法是:将GPUN这一组看成一个新的节点,按照前面的方案递归;又但是根节点为红就违反规则(2)了,怎么办,方法是直接将根节点设置为黑色(两个连续黑色是没问题的)。

②新插入节点N的父节点P是红色,叔叔节点U是黑色或者缺少,且新节点N是P的右孩子。

方法是:左旋父节点P。左旋后N和P角色互换,但是P和N还是连续的两个红色节点,还没有平衡,怎么办,看第三种情况。

③新插入节点N的父节点P是红色,叔叔节点U是黑色或者缺少,且新节点N是P的左孩子。

方法是:右旋祖父节点G,然后将P设置为黑色,G设置为红色,达到平衡。此时父节点P是黑色,所有不用担心P的父节点是红色。

当然上面说的三种情况都是基于一个前提:新插入节点N的父节点P是祖父节点G的左孩子,如果P是G的右孩子又是什么情况呢?其实情况和上面是相似的,只需要调整左旋还是右旋,这里就不细讲了。

TreeMap的实现:

public V put(K key, V value) {
    // 根节点
    Entry t = root;
    // 如果根节点为空,则直接创建一个根节点,返回
    if (t == null) {
        compare(key, key); // type check
        root = new Entry(key, value, null);
        size = 1;
        modCount++;
        return null;
    }
    // 记录比较结果
    int cmp;
    Entry parent;
    // split comparator and comparable paths
    // 当前使用的比较器
    Comparator cpr = comparator ;
    // 如果比较器不为空,就是用指定的比较器来维护TreeMap的元素顺序
    if (cpr != null) {
         // do while循环,查找key要插入的位置(也就是新节点的父节点是谁)
        do {
            // 记录上次循环的节点t
            parent = t;
            // 比较当前节点的key和新插入的key的大小
            cmp = cpr.compare(key, t. key);
             // 新插入的key小的话,则以当前节点的左孩子节点为新的比较节点
            if (cmp < 0)
                t = t. left;
            // 新插入的key大的话,则以当前节点的右孩子节点为新的比较节点
            else if (cmp > 0)
                t = t. right;
            else
          // 如果当前节点的key和新插入的key相等的话,则覆盖map的value,返回
                return t.setValue(value);
        // 只有当t为null,也就是没有要比较节点的时候,代表已经找到新节点要插入的位置
        } while (t != null);
    }
    else {
        // 如果比较器为空,则使用key作为比较器进行比较
        // 这里要求key不能为空,并且必须实现Comparable接口
        if (key == null)
            throw new NullPointerException();
        Comparable k = (Comparable) 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 e = new Entry(key, value, parent);
    // 如果新节点key的值小于父节点key的值,则插在父节点的左侧
    if (cmp < 0)
        parent. left = e;
    // 如果新节点key的值大于父节点key的值,则插在父节点的右侧
    else
        parent. right = e;
    // 插入新的节点后,为了保持红黑树平衡,对红黑树进行调整
    fixAfterInsertion(e);
    // map元素个数+1
    size++;
    modCount++;
    return null;
}


/** 新增节点后对红黑树的调整方法 */
private void fixAfterInsertion(Entry x) {
    // 将新插入节点的颜色设置为红色
    x. color = RED;

    // while循环,保证新插入节点x不是根节点或者新插入节点x的父节点不是红色(这两种情况不需要调整)
    while (x != null && x != root && x. parent.color == RED) {
        // 如果新插入节点x的父节点是祖父节点的左孩子
        if (parentOf(x) == leftOf(parentOf (parentOf(x)))) {
            // 取得新插入节点x的叔叔节点
            Entry y = rightOf(parentOf (parentOf(x)));
            // 如果新插入x的父节点是红色-------------------①
            if (colorOf(y) == RED) {
                // 将x的父节点设置为黑色
                setColor(parentOf (x), BLACK);
                // 将x的叔叔节点设置为黑色
                setColor(y, BLACK);
                // 将x的祖父节点设置为红色
                setColor(parentOf (parentOf(x)), RED);
                // 将x指向祖父节点,如果x的祖父节点的父节点是红色,按照上面的步奏继续循环
                x = parentOf(parentOf (x));
            } else {
                // 如果新插入x的叔叔节点是黑色或缺少,且x的父节点是祖父节点的右孩子-------------------②
                if (x == rightOf( parentOf(x))) {
                    // 左旋父节点
                    x = parentOf(x);
                    rotateLeft(x);
                }
                // 如果新插入x的叔叔节点是黑色或缺少,且x的父节点是祖父节点的左孩子-------------------③
                // 将x的父节点设置为黑色
                setColor(parentOf (x), BLACK);
                // 将x的祖父节点设置为红色
                setColor(parentOf (parentOf(x)), RED);
                // 右旋x的祖父节点
                rotateRight( parentOf(parentOf (x)));
            }
        } else { // 如果新插入节点x的父节点是祖父节点的右孩子,下面的步奏和上面的相似,只不过左旋右旋的区分,不在细讲
            Entry y = leftOf(parentOf (parentOf(x)));
            if (colorOf(y) == RED) {
                setColor(parentOf (x), BLACK);
                setColor(y, BLACK);
                setColor(parentOf (parentOf(x)), RED);
                x = parentOf(parentOf (x));
            } else {
                if (x == leftOf( parentOf(x))) {
                    x = parentOf(x);
                    rotateRight(x);
                }
                setColor(parentOf (x), BLACK);
                setColor(parentOf (parentOf(x)), RED);
                rotateLeft( parentOf(parentOf (x)));
            }
        }
    }
    // 最后将根节点设置为黑色,不管当前是不是红色,反正根节点必须是黑色
    root.color = BLACK;
}

/**
 * 对红黑树的节点(x)进行左旋转
 *
 * 左旋示意图(对节点x进行左旋):
 *      px                              px
 *     /                               /
 *    x                               y               
 *   /  \      --(左旋)--           / \                
 *  lx   y                          x  ry    
 *     /   \                       /  \
 *    ly   ry                     lx  ly 
 *
 */
private void rotateLeft(Entry p) {
    if (p != null) {
        // 取得要选择节点p的右孩子
        Entry r = p. right;
        // "p"和"r的左孩子"的相互指向...
        // 将"r的左孩子"设为"p的右孩子"
        p. right = r.left ;
        // 如果r的左孩子非空,将"p"设为"r的左孩子的父亲"
        if (r.left != null)
            r. left.parent = p;

        // "p的父亲"和"r"的相互指向...
        // 将"p的父亲"设为"y的父亲"
        r. parent = p.parent ;
        // 如果"p的父亲"是空节点,则将r设为根节点
        if (p.parent == null)
            root = r;
        // 如果p是它父节点的左孩子,则将r设为"p的父节点的左孩子"
        else if (p.parent. left == p)
            p. parent.left = r;
        else             
            // 如果p是它父节点的左孩子,则将r设为"p的父节点的左孩子"
            p. parent.right = r;
        // "p"和"r"的相互指向...
        // 将"p"设为"r的左孩子"
        r. left = p;
        // 将"p的父节点"设为"r"
        p. parent = r;
    }
}


/**
 * 对红黑树的节点进行右旋转
 *
 * 右旋示意图(对节点y进行右旋):
 *            py                               py
 *           /                                /
 *          y                                x                 
 *         /  \      --(右旋)--            /  \                     
 *        x   ry                           lx   y 
 *       / \                                   / \                   
 *      lx  rx                                rx  ry
 *
 */
private void rotateRight(Entry p) {
    if (p != null) {
        // 取得要选择节点p的左孩子
        Entry l = p. left;           
        // 将"l的右孩子"设为"p的左孩子"
        p. left = l.right ;
        // 如果"l的右孩子"不为空的话,将"p"设为"l的右孩子的父亲"
        if (l.right != null) l. right.parent = p;
        // 将"p的父亲"设为"l的父亲"
        l. parent = p.parent ;
        // 如果"p的父亲"是空节点,则将l设为根节点
        if (p.parent == null)
            root = l;      
        // 如果p是它父节点的右孩子,则将l设为"p的父节点的右孩子"
        else if (p.parent. right == p)
            p. parent.right = l;
        //如果p是它父节点的左孩子,将l设为"p的父节点的左孩子"
        else p.parent .left = l;
        // 将"p"设为"l的右孩子"
        l. right = p;
        // 将"l"设为"p父节点"
        p. parent = l;
    }
}

单纯的看代码和注释,绝对会发出,cha这是什么乱七八糟的,任谁也看不懂,所以一定要结合上面的图解,不懂了就看看图,然后动手画一下。如果你告诉我,还是没有懂,没问题可以理解,这里有一位大神录制的红黑树增加元素视频动画,来吧,http://v.youku.com/v_show/id_XNjI4NzgxMjA4.html(视频不是我录得,尊重版权,向大神致敬)。

红黑树的删除原理及TreeMap的remove实现

相比添加,红黑树的删除显得更加复杂了。看下红黑树的删除需要哪几个步奏:

  • 将红黑树当成一颗二叉查找树,将节点删除。
  • 通过旋转和着色,使它恢复平衡,重新变成一颗符合规则的红黑树。

删除节点的关键是:

  1. 如果删除的是红色节点,不会违背红黑树的规则。
  2. 如果删除的是黑色节点,那么这个路径上就少了一个黑色节点,则违背了红黑树的规则。

来看下红黑树删除节点会有哪几种情况:

  1. 被删除的节点没有孩子节点,即叶子节点。可直接删除。
  2. 被删除的节点只有一个孩子节点,那么直接删除该节点,然后用它的孩子节点顶替它的位置。
  3. 被删除的节点有两个孩子节点。这种情况二叉树的删除有一个技巧,就是查找到要删除的节点X,接着我们找到它左子树的最大元素M,或者它右子树的最小元素M,交换X和M的值,然后删除节点M。此时M就最多只有一个子节点N(若是左子树则没有右子节点,若是右子树则没有左子节点 ),若M没有孩子则进入(1)的情况,否则进入(2)的情况。

如上图,我们假定节点X是要删除的节点,而节点M是找到X右子树的最小元素,所以节点M是X的替代节点,也就是说M是真正要删除的节点。上面我们分析了此时的M只会有一个子节点N,当删除节点M后,N将替代M作为M节点的父节点的子节点。删除的节点M是黑色(删除红色不影响上面分析了),此时如果N是红色,只需将N设置为黑色,就会重新达到平衡,不会出现该路径上少了一个黑色节点的情况;但是如果N是红色,情况则比较复杂,需要对红黑树进行调整,而这种情况又分为了以下几种,下面进行图解:

①N的兄弟节点B是红色。

方法是:交换P和B的颜色,左旋父节点P。此时并未完成平衡,左子树仍然少了一个黑色节点,进入情况③。(B为红色,P必然为黑色)

②N的父节点P是黑色,且兄弟节点B和它的两个孩子节点也都是黑色。

方法是:将N的兄弟节点B改为红色,这样从P出发到叶子节点的路径都包含了相同的黑色节点,但是,对于节点P这个子树,P的父节点G到P的叶子节点路径上的黑色节点就少了一个,此时需要将P整体看做一个节点,继续调整。

③N的父节点P为红色,兄弟节点B和它的两个孩子节点也都是黑色。

此时只需要交换P和B的颜色,将P改为黑色,B改为红色,则可到达平衡。这相当于既然节点N路径少了一个黑色节点,那么B路径也少一个黑色节点,这两个路径达到平衡,为了防止P路径少一个黑色节点,将P节点置黑,则达到最终平衡。

④N的兄弟节点B是黑色,B的左孩子节点BL是红色,B的右孩子节点BR是黑色,P为任意颜色。

方法是:交换B和BL的颜色,右旋节点B。此时N子树路径并没有增加黑色节点,也就是没有达到平衡,此时进入下一种情况⑤。

⑤N的兄弟节点B是黑色,B的右孩子节点BR是红色,B的左孩子节点BL任意颜色,P任意颜色。

方法是:BR变为黑色,P变为黑色,B变为P的颜色;左旋节点B。首先给N路径增加一个黑色节点P,P原位置上的颜色不变;S路径少了一个黑色节点,于是将BR改为黑色,最终达到了平衡。

上面对红黑树删除的原理和删除过程中遇到的情况进行了分析说明,我们得到的结论是红黑树的删除遇到的主要问题就是被删除路径上的黑色节点减少,于是需要进行一系列旋转和着色,当然上面的情况是基于M是X右子树的最小元素,而M如果是X左子树的最大元素和上面的情况是相似的。

TreeMap的代码是怎么实现的:

public V remove(Object key) {
    // 根据key查找到对应的节点对象
    Entry p = getEntry(key);
    if (p == null)
        return null;

    // 记录key对应的value,供返回使用
    V oldValue = p.value;
    // 删除节点
    deleteEntry(p);
    return oldValue;
}


private void deleteEntry(Entry p) {
    modCount++;
    // map容器的元素个数减一
    size--;

    // If strictly internal, copy successor's element to p and then make p
    // point to successor.
    // 如果被删除的节点p的左孩子和右孩子都不为空,则查找其替代节点-----------这里表示要删除的节点有两个孩子(3)
    if (p.left != null && p. right != null) {
        // 查找p的替代节点
        Entry s = successor (p);
        p. key = s.key ;
        p. value = s.value ;
        // 将p指向替代节点,※※※※※※从此之后的p不再是原先要删除的节点p,而是替代者p(就是图解里面讲到的M) ※※※※※※
        p = s;
    } // p has 2 children

    // Start fixup at replacement node, if it exists.
    // replacement为替代节点p的继承者(就是图解里面讲到的N),p的左孩子存在则用p的左孩子替代,否则用p的右孩子
    Entry replacement = (p. left != null ? p.left : p. right);

    if (replacement != null) { // 如果上面的if有两个孩子不通过--------------这里表示要删除的节点只有一个孩子(2)
        // Link replacement to parent
        // 将p的父节点拷贝给替代节点
        replacement. parent = p.parent ;
        // 如果替代节点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;

        // Null out links so they are OK to use by fixAfterDeletion.
        // 将替代节点p的left、right、parent的指针都指向空,即解除前后引用关系(相当于将p从树种摘除),使得gc可以回收
        p. left = p.right = p.parent = null;

        // Fix replacement
        // 如果替代节点p的颜色是黑色,则需要调整红黑树以保持其平衡
        if (p.color == BLACK)
            fixAfterDeletion(replacement);
    } else if (p.parent == null) { // return if we are the only node.
        // 如果要替代节点p没有父节点,代表p为根节点,直接删除即可
        root = null;
    } else { //  No children. Use self as phantom replacement and unlink.
        // 判断进入这里说明替代节点p没有孩子--------------这里表示没有孩子则直接删除(1)
        // 如果p的颜色是黑色,则调整红黑树
        if (p.color == BLACK)
            fixAfterDeletion(p);
        // 下面删除替代节点p
        if (p.parent != null) {
            // 解除p的父节点对p的引用
            if (p == p.parent .left)
                p. parent.left = null;
            else if (p == p.parent. right)
                p. parent.right = null;
            // 解除p对p父节点的引用
            p. parent = null;
        }
    }
}

/**
 * 查找要删除节点的替代节点
 */
static  TreeMap.Entry successor(Entry t) {
    if (t == null)
        return null;
    // 查找右子树的最左孩子
    else if (t.right != null) {
        Entry p = t. right;
        while (p.left != null)
            p = p. left;
        return p;
    } else { // 查找左子树的最右孩子
        Entry p = t. parent;
        Entry ch = t;
        while (p != null && ch == p. right) {
            ch = p;
            p = p. parent;
        }
        return p;
    }
}

/** From CLR */
private void fixAfterDeletion(Entry x) {
    // while循环,保证要删除节点x不是跟节点,并且是黑色(根节点和红色不需要调整)
    while (x != root && colorOf (x) == BLACK) {
        // 如果要删除节点x是其父亲的左孩子
        if (x == leftOf( parentOf(x))) {
            // 取出要删除节点x的兄弟节点
            Entry sib = rightOf(parentOf (x));

            // 如果删除节点x的兄弟节点是红色---------------------------①
            if (colorOf(sib) == RED) {
                // 将x的兄弟节点颜色设置为黑色
                setColor(sib, BLACK);
                // 将x的父节点颜色设置为红色
                setColor(parentOf (x), RED);
                // 左旋x的父节点
                rotateLeft( parentOf(x));
                // 将sib重新指向旋转后x的兄弟节点 ,进入else的步奏③
                sib = rightOf(parentOf (x));
            }

            // 如果x的兄弟节点的两个孩子都是黑色-------------------------③
            if (colorOf(leftOf(sib))  == BLACK &&
                colorOf(rightOf (sib)) == BLACK) {
                // 将兄弟节点的颜色设置为红色
                setColor(sib, RED);
                // 将x的父节点指向x,如果x的父节点是黑色,需要将x的父节点整天看做一个节点继续调整-------------------------②
                x = parentOf(x);
            } else {
                // 如果x的兄弟节点右孩子是黑色,左孩子是红色-------------------------④
                if (colorOf(rightOf(sib)) == BLACK) {
                    // 将x的兄弟节点的左孩子设置为黑色
                    setColor(leftOf (sib), BLACK);
                    // 将x的兄弟节点设置为红色
                    setColor(sib, RED);
                    // 右旋x的兄弟节点
                    rotateRight(sib);
                    // 将sib重新指向旋转后x的兄弟节点,进入步奏⑤
                    sib = rightOf(parentOf (x));
                }
                // 如果x的兄弟节点右孩子是红色-------------------------⑤
                setColor(sib, colorOf (parentOf(x)));
                // 将x的父节点设置为黑色
                setColor(parentOf (x), BLACK);
                // 将x的兄弟节点的右孩子设置为黑色
                setColor(rightOf (sib), BLACK);
                // 左旋x的父节点
                rotateLeft( parentOf(x));
                // 达到平衡,将x指向root,退出循环
                x = root;
            }
        } else { // symmetric // 如果要删除节点x是其父亲的右孩子,和上面情况一样,这里不再细讲
            Entry sib = leftOf(parentOf (x));

            if (colorOf(sib) == RED) {
                setColor(sib, BLACK);
                setColor(parentOf (x), RED);
                rotateRight( parentOf(x));
                sib = leftOf(parentOf (x));
            }

            if (colorOf(rightOf(sib)) == BLACK &&
                colorOf(leftOf (sib)) == BLACK) {
                setColor(sib, RED);
                x = parentOf(x);
            } else {
                if (colorOf(leftOf(sib)) == BLACK) {
                    setColor(rightOf (sib), BLACK);
                    setColor(sib, RED);
                    rotateLeft(sib);
                    sib = leftOf(parentOf (x));
                }
                setColor(sib, colorOf (parentOf(x)));
                setColor(parentOf (x), BLACK);
                setColor(leftOf (sib), BLACK);
                rotateRight( parentOf(x));
                x = root;
            }
        }
    }

    setColor(x, BLACK);
}

删除相对来说更加复杂,还是那句话一定要对照着图解看代码,否则是读不懂的,别问我是怎么看懂得,我n天不看再看代码也不知道123了。

终于看完了红黑树的增加和删除,下面来看个稍微简单的查询。

红黑树TreeMap的查询

public V get(Object key) {
    Entry p = getEntry(key);
    return (p==null ? null : p. value);
}

final Entry getEntry(Object key) {
    // Offload comparator-based version for sake of performance
    if (comparator != null)
        // 如果比较器为空,只是用key作为比较器查询
        return getEntryUsingComparator(key);
    if (key == null)
        throw new NullPointerException();
   Comparable k = (Comparable) key;
    // 取得root节点
    Entry p = root;
    // 从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;
}

final Entry getEntryUsingComparator(Object key) {
   K k = (K) key;
    Comparator cpr = comparator ;
    if (cpr != null) {
        Entry p = root;
        while (p != null) {
            int cmp = cpr.compare(k, p.key );
            if (cmp < 0)
                p = p. left;
            else if (cmp > 0)
                p = p. right;
            else
                return p;
        }
    }
    return null;
}

到此TreeMap就分析完了,其实大部分时间都在整理红黑树,在数据结构中树是比较难懂的一个,其算法也比较复杂,对于树的理解一定要多看图画图,要明白这么做是为了解决什么问题,这么做又有什么好处,当然看一遍看不懂就要多看几遍了。

红黑树演示:https://www.cs.usfca.edu/~galles/visualization/RedBlack.html

你可能感兴趣的:(java集合框架)