Java知识点总结（Java容器-TreeSet）

摘要：知识点总结容器知识点总结容器是接口的唯一实现，可以确保集合元素处于排序状态，底层是一棵排序树。底层使用红黑树算法进行维护，因此性能相对于来说要差一些，因为内部会自动进行排序操作。

@(Java知识点总结)[Java, Java容器, JavaCollection, JavaSet]

TreeSet是SortedSet接口的唯一实现，TreeSet可以确保集合元素处于排序状态，底层是一棵排序树。

底层使用红黑树算法进行维护，因此性能相对于HashSet来说要差一些，因为内部会自动进行排序操作。

TreeSet也是线程不安全

排序分为自然排序，定制排序，自然排序是TreeSet内部对add进来的值进行排序，定制排序是对排序条件的限制

package mySet;  
  
import java.util.Comparator;  
import java.util.Iterator;  
import java.util.NoSuchElementException;  
  
/** 
 * 实现一个简单的TreeSet 
 * @author george 
 */  
public class MyTreeSet implements Cloneable, java.io.Serializable {  
    // 为set底层树的结构排序用的比较器 当按照E的自然排序时为null  
    private final Comparator comparator;  
    // 头节点  
    private transient SetNode root = null;  
    // 节点个数  
    private transient int size = 0;  
  
    /** 
     * 无参构造，设置比较器为null 
     */  
    public MyTreeSet() {  
        comparator = null;  
    }  
  
    /** 
     * 构造函数，传入定义好的比较器对象 
     *  
     * @param comparator 
     *            ：比较器对象 
     */  
    public MyTreeSet(Comparator comparator) {  
        this.comparator = comparator;  
    }  
  
    /** 
     * 插入对象e到MyTreeSet中 
     *  
     * @param e 
     *            ：要插入的对象 
     * @return：返回是否插入成功 
     */  
    public boolean add(E e) {  
        SetNode n = root;  
        if (n == null) {  
            root = new SetNode(e, null);  
            size = 1;  
            return true;  
        }  
        int comp;  
        SetNode parents;  
        Comparator cptor = comparator;  
        // 若比较器不为空 用Comparator进行比较  
        if (cptor != null) {  
            do {  
                parents = n;  
                comp = cptor.compare(e, n.e);  
                if (comp < 0)  
                    n = n.left;  
                else if (comp > 0)  
                    n = n.right;  
                else {  
                    return false;  
                }  
            } while (n != null);  
        } else {  
            if (e == null)  
                throw new NullPointerException();  
            // 用定义好的自然顺序方法进行排序比较  
            Comparable cpb = (Comparable) e;  
            do {  
                parents = n;  
                comp = cpb.compareTo(n.e);  
                if (comp < 0)  
                    n = n.left;  
                else if (comp > 0)  
                    n = n.right;  
                else {  
                    return false;  
                }  
            } while (n != null);  
        }  
        // 找到新元素将来位置的父结点后，将元素实例化成结点插入到树中  
        SetNode newNode = new SetNode(e, parents);  
        if (comp < 0)  
            parents.left = newNode;  
        else  
            parents.right = newNode;  
        size++;  
        return true;  
    }  
  
    /** 
     * 返回是否含有元素e 
     *  
     * @param e 
     * @return 
     */  
    public boolean contains(E e) {  
        return getNode(e) != null;  
    }  
  
    /** 
     * 删除元素e所在的结点 
     *  
     * @param e 
     * @return 
     */  
    public boolean remove(E e) {  
        SetNode node = getNode(e);// 找到元素e所在节点  
        if (node == null)  
            return false;  
        deleteNode(node);// 进行删除  
        return true;  
    }  
  
    /** 
     * 找到元素e在树中的结点 
     *  
     * @param e 
     * @return 
     */  
    private SetNode getNode(E e) {  
        SetNode n = root;  
        int comp;  
        SetNode parents;  
        Comparator cptor = comparator;  
        // 若比较器不为空 用Comparator进行比较  
        if (cptor != null) {  
            do {  
                parents = n;  
                comp = cptor.compare(e, n.e);  
                if (comp < 0)  
                    n = n.left;  
                else if (comp > 0)  
                    n = n.right;  
                else {  
                    return parents;  
                }  
            } while (n != null);  
        } else {  
            if (e == null)  
                throw new NullPointerException();  
            // 用定义好的自然顺序方法进行排序比较  
            Comparable cpb = (Comparable) e;  
            do {  
                parents = n;  
                comp = cpb.compareTo(n.e);  
                if (comp < 0)  
                    n = n.left;  
                else if (comp > 0)  
                    n = n.right;  
                else {  
                    return parents;  
                }  
            } while (n != null);  
        }  
        return null;  
    }  
  
    /** 
     * 删除树中的节点node 当结点node有左右子女时，往下所搜与node中的元素最为接近的元素的结点 
     * 找到后将该结点的元素值赋给node，让node指向该结点， 接下来删除这个结点。 注意：最后要去掉的节点的子女个数都是小于2的 
     *  
     * @param node 
     */  
    void deleteNode(SetNode node) {  
        size--;  
        SetNode rep;  
        if (node.left != null && node.right != null) {  
            rep = replaceNode(node);  
            node.e = rep.e;  
            node = rep;  
        }  
        rep = (node.left != null ? node.left : node.right);  
  
        if (rep != null) {  
            rep.parents = node.parents;  
            if (node.parents == null)  
                root = rep;  
            else if (node == node.parents.left)  
                node.parents.left = rep;  
            else if (node == node.parents.right)  
                node.parents.right = rep;  
        } else {  
            if (node.parents == null) {  
                root = null;  
            }  
            if (node.parents != null) {  
                if (node == node.parents.left)  
                    node.parents.left = null;  
                else if (node == node.parents.right)  
                    node.parents.right = null;  
            }  
        }  
    }  
  
    /** 
     * 找到距离node中的元素大小最近的结点 
     *  
     * @param node 
     * @return 
     */  
    SetNode replaceNode(SetNode node) {  
        if (node == null)  
            return null;  
        else if (node.right != null) {  
            SetNode p = node.right;  
            while (p.left != null)  
                p = p.left;  
            return p;  
        } else {  
            SetNode p = node.parents;  
            SetNode ch = node;  
            while (p != null && ch == p.right) {  
                ch = p;  
                p = p.parents;  
            }  
            return p;  
        }  
    }  
  
    /** 
     * 清空set集合 
     */  
    public void clear() {  
        size = 0;  
        root = null;  
    }  
  
    /** 
     * 返回结点的个数 
     *  
     * @return 
     */  
    public int size() {  
        return size;  
    }  
  
    /** 
     * 找到最小的元素 
     *  
     * @return 
     */  
    public E first() {  
        SetNode p = root;  
        if (p != null)  
            while (p.left != null)  
                p = p.left;  
        if (p.e == null)  
            throw new NoSuchElementException();  
        else  
            return p.e;  
    }  
  
    /** 
     * 找到最大的元素 
     *  
     * @return 
     */  
    public E last() {  
        SetNode p = root;  
        if (p != null)  
            while (p.right != null)  
                p = p.right;  
        if (p.e == null)  
            throw new NoSuchElementException();  
        else  
            return p.e;  
    }  
  
    /** 
     * 找到最小的元素所在的结点 
     *  
     * @return 
     */  
    public SetNode firstNode() {  
        SetNode p = root;  
        if (p != null)  
            while (p.left != null)  
                p = p.left;  
        if (p.e == null)  
            throw new NoSuchElementException();  
        else  
            return p;  
    }  
  
    /** 
     * 迭代器 
     * @return 
     */  
    public Iterator iterator() {  
        return new KeyIterator(firstNode(), this);  
    }  
}