TreeSet和TreeMap

TreeSet和TreeMap

一、TreeSet调试用例

package com.liu.collection;

import java.util.TreeSet;

public class TreeSet_ {
    public static void main(String[] args) {
        //treeset底层是treemap
//       comparator 用于维护此树映射中的顺序的比较器,或
//        如果使用其键的自然顺序,则为null。
        TreeSet<Object> treeSet = new TreeSet<>();
        treeSet.add("aaa");
        treeSet.add("zaa");
        treeSet.add("daa");
        treeSet.add("dba");
        treeSet.add("gaa");
        System.out.println(treeSet);
    }
}

二、TreeSet的debug

进入TreeSet构造函数

发现默认采用自然排序

底层为TreeMap

/**
 * 使用树的自然顺序构造一个新的空树映射
 *钥匙。插入到映射中的所有键都必须实现{@link
 *可比}接口。此外,所有此类钥匙必须
 *相互可比的</em>:{@code k1.compareTo(k2)}不能抛出
 *任何键{@code k1}的{@code ClassCastException}和
 *{@code k2}在地图中。如果用户试图将密钥放入
 *违反此约束的映射(例如,用户尝试
 *将字符串键放入一个键为整数的映射中
 *{@code put(对象键,对象值)}调用将抛出
 *{@code ClassCastException}。
 */
public TreeSet() {
    this(new TreeMap<E,Object>());
}

进入TreeMap构造函数

    /**
     * The comparator used to maintain order in this tree map, or
     * null if it uses the natural ordering of its keys.
     *用于维护此树映射中的顺序的比较器,或
	 *如果使用其键的自然顺序,则为null。
     * @serial
     */
private final Comparator<? super K> comparator;
/**
 * 使用树的自然顺序构造一个新的空树映射
 *钥匙。插入到映射中的所有键都必须实现{@link
 *可比}接口。此外,所有此类钥匙必须
 *相互可比的</em>:{@code k1.compareTo(k2)}不能抛出
 *任何键{@code k1}的{@code ClassCastException}和
 *{@code k2}在地图中。如果用户试图将密钥放入
 *违反此约束的映射(例如,用户尝试
 *将字符串键放入一个键为整数的映射中
 *{@code put(对象键,对象值)}调用将抛出
 *{@code ClassCastException}。
 */

public TreeMap() {
    comparator = null;
}

进入AbstractMap<K,V>

treemap继承了AbstractMap类

跳出AbstractMap<K,V>

跳出TreeMap

进入 this(new TreeMap<E,Object>());

/**
 * Constructs a set backed by the specified navigable map.
 */
TreeSet(NavigableMap<E,Object> m) {
    this.m = m;
}

跳出TreeSet

进入add方法

public boolean add(E e) {
    return m.put(e, PRESENT)==null;
}

进入put方法(treemap的put方法)

public V put(K key, V value) {
    //记录当前根结点的值
    Entry<K,V> t = root;
    //若根结点为空
    if (t == null) {
        //则比较key和key的大小
        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();
        @SuppressWarnings("unchecked")
            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;
}

进入compare

/**
 * Compares two keys using the correct comparison method for this TreeMap.
 */
@SuppressWarnings("unchecked")
final int compare(Object k1, Object k2) {
    //若comparator为空,则
    return comparator==null ? ((Comparable<? super K>)k1).compareTo((K)k2)
        : comparator.compare((K)k1, (K)k2);
}

进入String类中的compareTo方法

自然排序

从前往后比较字符串的字母,直到遍历到第一个不相同的字母,返回两个字母差值的ASC码值

例题:

abc>acc acc<accs

a>bbb aaa=aaa

public int compareTo(String anotherString) {
    //value可以调用compareTo方法,所以在调用前,就已经将value的值加载到String类中了
    int len1 = value.length;
    int len2 = anotherString.value.length;
    //lim是两传入字符串的长度最小值
    int lim = Math.min(len1, len2);
    char v1[] = value;
    char v2[] = anotherString.value;

    int k = 0;
    //知道遍历到较短字符串的末尾
    while (k < lim) {
        char c1 = v1[k];
        char c2 = v2[k];
        //若不相等,则返回差值的Asc
        if (c1 != c2) {
            return c1 - c2;
        }
        k++;
    }
    //若遍历到较短字符串的末尾,两字符串都相等,则返回两字符串的长度差值
    return len1 - len2;
}

回到put方法

public V put(K key, V value) {
    //记录当前根结点的值
    Entry<K,V> t = root;
    //若根结点为空
    if (t == null) {
        //则比较key和key的大小
        compare(key, key); // type (and possibly null) check

        //新建节点,并赋值给root
        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 {//若comparator为null,且根结点不为null,add大于等于第二个结点时
        if (key == null)
            throw new NullPointerException();
        @SuppressWarnings("unchecked")
            Comparable<? super K> k = (Comparable<? super K>) key;
        do {
            //记录当前遍历到的根节点,每遍历一次,重新记录一次
            parent = t;
            //按照自然排序比较两key,并返回一个差值,用来判别大小
            cmp = k.compareTo(t.key);
            //若第一个值小
            if (cmp < 0)
                //t结点指向左孩子
                t = t.left;
            //若第一个值大于第二个值,
            else if (cmp > 0)
                //往根结点的右面找,符合二叉查找树的特点,给根节点重新赋值,
                //t结点指向右孩子
                t = t.right;
            else//若key相等
                //则替换为当前value
                return t.setValue(value);
        } while (t != null);//直到当前遍历到的结点为null
    }
    //新建结点,其父节点为parent
    Entry<K,V> e = new Entry<>(key, value, parent);
    //若 要加入的值 小于 遍历到的结点(parent) 的值
    if (cmp < 0)
        //将要加入的值放于遍历到的结点的左孩子
        parent.left = e;
    else
        //放到右孩子
        parent.right = e;
    fixAfterInsertion(e);
    size++;
    modCount++;
    return null;
}

红黑树Entry

双向的含有子结点和parent结点

static final class Entry<K,V> implements Map.Entry<K,V> {
    K key;
    V value;
    Entry<K,V> left;
    Entry<K,V> right;
    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;
    }

修正红黑树的颜色(本节不做详述,下节详细叙述)

/** From CLR */
private void fixAfterInsertion(Entry<K,V> x) {
    x.color = RED;

    while (x != null && x != root && x.parent.color == RED) {
        if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
            Entry<K,V> y = rightOf(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 == rightOf(parentOf(x))) {
                    x = parentOf(x);
                    rotateLeft(x);
                }
                setColor(parentOf(x), BLACK);
                setColor(parentOf(parentOf(x)), RED);
                rotateRight(parentOf(parentOf(x)));
            }
        } else {
            Entry<K,V> 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;
}

回到add

添加成功

三、总结

TreeSet的底层是TreeMap

TreeMap采用红黑树的存储方式,红黑树是一种特殊的二叉搜索树

红黑树的性质:

1.每个节点或是红色的,或是黑色的

2.根节点是黑色的

3.每个叶节点(NIL)是黑色的

4.如果一个节点是红色的,则它的两个子节点都是黑色的

5.对于每个几点,从该节点到其所有后代叶节点的简单路径上,均包含相同数目的黑色节点。

TreeMap默认采用自然排序的方式

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值