摘要:知识点总结容器知识点总结容器是接口的唯一实现,可以确保集合元素处于排序状态,底层是一棵排序树。底层使用红黑树算法进行维护,因此性能相对于来说要差一些,因为内部会自动进行排序操作。
Java知识点总结(Java容器-TreeSet)
@(Java知识点总结)[Java, Java容器, JavaCollection, JavaSet]
TreeSetTreeSet是SortedSet接口的唯一实现,TreeSet可以确保集合元素处于排序状态,底层是一棵排序树。
底层使用红黑树算法进行维护,因此性能相对于HashSet来说要差一些,因为内部会自动进行排序操作。
TreeSet也是线程不安全
排序分为自然排序,定制排序,自然排序是TreeSet内部对add进来的值进行排序,定制排序是对排序条件的限制
手动实现TreeSet</>复制代码
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);
}
}
文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。
转载请注明本文地址:https://www.ucloud.cn/yun/69630.html
摘要:知识点总结容器知识点总结容器是一种不包括重复元素的。由于接口的特殊性,所有传入集合中的元素必须不同。集合判断两个对象是否相同,是使用方法,而不是使用运算符的。只能存储,所以只会在存储的情况下使用。 Java知识点总结(Java容器-Set) @(Java知识点总结)[Java, Java容器, JavaCollection, JavaSet] Set Set是一种不包括重复元素的Col...
摘要:知识点总结容器知识点总结容器函数库是包下的一些接口和类,类是用来产生对象存放数据用的,而接口是访问数据的方式。底层也是数组实现,线程安全,效率低效率高,线程不安全。 Java知识点总结(Java容器-Collection) @(Java知识点总结)[Java, Java容器, JavaCollection] [toc] Collection Collection函数库是java.uti...
摘要:是哈希表实现的,中的数据是无序的,可以放入,但只能放入一个,两者中的值都不能重复,就如数据库中唯一约束。四和的相同点和区别相同两者都是基于哈希表实现的内部也都是通过单链表解决冲突问题同样实现了序列化和克隆接口区别继承的父类不同。 一.Arraylist与LinkedList有什么区别? 1、ArrayList是实现了基于动态数组的数据结构,因为地址连续,一旦数据存储好了,查询操作效率...
摘要:集合中成员很丰富,常用的集合有,,等。实现接口的集合主要有。集合中不能包含重复的元素,每个元素必须是唯一的。而以作为实现的构造函数的访问权限是默认访问权限,即包内访问权限。与接口不同,它是由一系列键值对组成的集合,提供了到的映射。 原文地址 Java集合 Java集合框架:是一种工具类,就像是一个容器可以存储任意数量的具有共同属性的对象。 Java集合中成员很丰富,常用的集合有Arra...
阅读 1343·2019-08-30 15:44
阅读 1403·2019-08-29 18:42
阅读 452·2019-08-29 13:59
阅读 792·2019-08-28 17:58
阅读 2832·2019-08-26 12:02
阅读 2434·2019-08-23 18:40
阅读 2423·2019-08-23 18:13
阅读 3125·2019-08-23 16:27