Java实现TreeSet集合

最新推荐文章于 2023-02-18 11:49:31 发布
最新推荐文章于 2023-02-18 11:49:31 发布
阅读量454 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Erictr/article/details/121311637
版权

java 后端 数据结构

Java实现TreeSet集合

Java中Set作为一个接口，有两种实现方式，一种是HashSet，另一种是TreeSet集合，此篇文章只讲解TreeSet的实现原理：
TreeSet是一种排序树，当我们随意插入数据后，TreeSet可以自动帮我们从小到大进行排序，事实上是调用了中序遍历二叉树的方法：
例子
TreeSet的主要特点很明显，就是左子树上的数据一定全部都小于右子树上的数据，一般约定不存在重复数据，下面是具体的实现代码，一共大概300多行，不过其中有一部分是get和set方法，具体查看时，只需找到相应的功能部分即可，每一个功能模块我都给出来注释：

package collection.eric;
//import java.util.Scanner;
public class TreeSet {
	public static void main(String[] args) {
		BinaryTree binaryTree = new BinaryTree();
//		Scanner scan = new Scanner(System.in);
		//当输入"#"时，终止输入
//		while(true) {
//			String number = scan.next();
//			if(number == "#") {
//				break;
//			}
//			binaryTree.add(new TreeNode(Integer.parseInt(number)));
//		}
		binaryTree.add(new TreeNode(8));
		binaryTree.add(new TreeNode(4));		
		binaryTree.add(new TreeNode(10));
		binaryTree.add(new TreeNode(7));
		binaryTree.add(new TreeNode(11));
		binaryTree.add(new TreeNode(1));
		binaryTree.midOrder();
		boolean result = binaryTree.deleTreeNode(10);
		System.out.println(result);
		binaryTree.midOrder();
		
	}
}
//二叉树
class BinaryTree{
	private TreeNode root;
	
	public BinaryTree() {
		
	}
	public void setRoot(TreeNode root) {
		this.root = root;
	}
	//增加节点
	public void add(TreeNode node) {
		if(root == null) {
			root = node;
		}else {
			root.add(node);
		}
	}
	//前序遍历
	public void preOrder() {
		if(this.root != null) {
			this.root.preOrder();
		}else {
			System.out.println("当前二叉树为空，请先创建二叉树！！");
		}
	}
	//中序遍历
	public void midOrder() {
		if(this.root != null) {
			this.root.midOrder();
		}else {
			System.out.println("当前二叉树为空，请先创建二叉树");
		}
	}
	//后序遍历
	public void postOrder() {
		if(this.root != null) {
			this.root.postOrder();
		}else {
			System.out.println("当前二叉树为空，请先创建二叉树");
		}
	}
	//前序查找
	public boolean preSearch(int data) {
		boolean result = false;
		if(this.root != null) {
			result = this.root.preSearch(data);
		}
		return result;
	}
	//中序查找
	public boolean midSearch(int data) {
		boolean result = false;
		if(this.root != null) {
			result = this.root.midSearch(data);
		}
		return result;
	}
	//后序查找
	public boolean postSearch(int data) {
		boolean result = false;
		if(this.root != null) {
			result = this.root.postSearch(data);
		}
		return result;
	}
	//查找要删除的节点
	private TreeNode nodeSearch(int data) {
		if(this.root == null) {
			return null;
		}else {
			return this.root.nodeSearch(data);
		}
	}
	//查找要删除节点的父节点
	private TreeNode parentSearch(int data) {
		if(this.root == null) {
			return null;
		}else {
			return this.root.parentSearch(data);
		}
	}
	//删除并返回以treeNode为根节点的最小值
	private int deleTreeMin(TreeNode treeNode) {
		TreeNode target = treeNode;
		while(target.getLeft() != null) {
			target = target.getLeft();
		}
		int data = target.getData();
		deleTreeNode(target.getData()); 
		return data;
	}
	//删除节点
	public boolean deleTreeNode(int data) {
		if(this.root == null) {
			return true;
		}else {
			TreeNode targetNode = nodeSearch(data);
			if(targetNode == null) {
				return false;
			}
			if(this.root.getData() == data && this.root.getLeft() == null && this.root.getRight() == null) {
				this.root = null;
				return true;
			}
			TreeNode parentNode = parentSearch(data);
			//删除叶子节点
			if(targetNode.getLeft() == null && targetNode.getRight() == null) {
				if(parentNode.getLeft() != null && targetNode.getData() == parentNode.getLeft().getData()) {
					parentNode.setLeft(null);
					return true;
				}else if(parentNode.getRight() != null && targetNode.getData() == data) {
					parentNode.setRight(null);
					return true;
				}
			}else if(targetNode.getRight() != null && targetNode.getLeft() != null){//删除有两个子树的节点
				int minNumber = deleTreeMin(targetNode.getRight());
				targetNode.setData(minNumber);
			}else {
				if(targetNode.getLeft() != null) {
					if(parentNode.getLeft().getData() == data) {
						parentNode.setLeft(targetNode.getLeft());
						return true;
					}else if(parentNode.getRight().getData() == data) {
						parentNode.setRight(targetNode.getLeft());
						return true;
					}
				}else if(targetNode.getRight() != null) {
					if(parentNode.getLeft().getData() == data) {
						parentNode.setLeft(targetNode.getRight());
						return true;
					}else if(parentNode.getRight().getData() == data) {
						parentNode.setRight(targetNode.getRight());
						return true;
					}
				}
			}
		}
		return false;
	}
}
//树节点
class TreeNode{
	private int data;
	private TreeNode left;
	private TreeNode right;
	public TreeNode(){
		this.left = null;
		this.right = null;
	}
	public TreeNode(int data) {
		this.data = data;
	}
	public void setData(int data) {
		this.data = data;
	}
	public int getData() {
		return this.data;
	}
	public void setLeft(TreeNode left) {
		this.left = left;
	}
	public TreeNode getLeft() {
		return this.left;
	}
	public void setRight(TreeNode right) {
		this.right = right;
	}
	public TreeNode getRight() {
		return this.right;
	}
	//递归添加节点
	public void add(TreeNode node) {
		if(node==null){
			return;
		}
		if(node.data == this.data) {
			return;
		}
		if(node.data < this.data) {
			if(this.left == null) {
				this.left = node;
			}else {
				this.left.add(node);
			}
		}else {
			if(this.right == null) {
				this.right = node;
			}else {
				this.right.add(node);
			}
		}
	}
	//前序遍历二叉树
	public void preOrder() {
		System.out.print(this.data+" ");
		if(this.left != null) {
			this.left.preOrder();
		}
		if(this.right != null) {
			this.right.preOrder();
		}
	}
	//中序遍历
	public void midOrder(){
		if(this.left != null) {
			this.left.midOrder();
		}
		System.out.print(this.data+" ");
		if(this.right != null) {
			this.right.midOrder();
		}
	}
	//后序遍历
	public void postOrder() {
		if(this.left != null) {
			this.left.postOrder();
		}
		if(this.right != null) {
			this.right.postOrder();
		}
		System.out.print(this.data+" ");
	}
	//前序查找
	public boolean preSearch(int data) {
		
		if(this.data == data) {
			return true;
		}
		boolean result = false;
		if(this.left != null) {
			result = this.left.preSearch(data);
		}
		if(result == true) {
			return true;
		}
		if(this.right != null) {
			result = this.right.preSearch(data);
		}
		return result;
	}
	//中序查找
	public boolean midSearch(int data) {
		boolean result = false;	
		if(this.left != null) {
			result = this.left.midSearch(data);
		}
		if(result == true) {
			return true;
		}
		if(this.data == data) {
			return true;
		}
		if(this.right != null) {
			result = this.right.midSearch(data);
		}
		return result;
	}
	//后序查找
	public boolean postSearch(int data) {
		boolean result = false;
		if(this.left != null) {
			result =  this.left.postSearch(data);
		}
		if(result == true) {
			return true;
		}
		if(this.right != null) {
			result = this.right.postSearch(data);
		}
		if(result == true) {
			return true;
		}
		if(this.data == data) {
			return true;
		}
		return result;
	}
	//查找要删除的节点
	public TreeNode nodeSearch(int data) {
		if(this.data == data) {
			return this;
		}else if(this.data > data) {
			if(this.left != null) {
				return this.left.nodeSearch(data);
			}
			return null;
		}else {
			if(this.right != null) {
				return this.right.nodeSearch(data);
			}
			return null;
		}
	}
	//查找要删除节点的父节点
	public TreeNode parentSearch(int data) {
		if((this.left != null && this.left.data == data)||(this.right != null && this.right.data == data)) {
			return this;
		}else {
			if(this.data > data && this.left != null) {
				return this.left.parentSearch(data);
			}else if(this.data <data && this.right != null) {
				return this.right.parentSearch(data);
			}else {
				return null;
			}
		}
	}

	
}

此代码中较难部分的逻辑是删除节点的逻辑，删除节点时应该先找到要删除节点的父节点，然后在进行删除相应节点，一共需要考虑到三种情况：
1、删除叶子结点
算法：判断该节点是父节点的左子节点还是右子节点
若是左子节点，则parentNode.setLeft(null);
若是右子节点，则parentNode. setRight(null);
假设我们要删除60
删除60

2、删除只有一个子节点的结点
算法：a.若要删除的节点为父节点的左子节点
1）该节点具有一个左子节点
parentNode.setLeft(targetNode.getLeft());
假设我们要删除50
删除50

  1. 该节点具有一个右子节点
    parentNode.setLeft(targetNode.getRight());
    在这里插入图片描述
    b.要删除的节点是父节点的右子节点
    1）该节点有一个左子节点
    parentNode.setRight(targetNode.getLeft());
    targetNode
    这个和上面两个类似，画图太累就不画了，理解就Ok
    2）该节点有一个右子节点
    parentNode.setRight(targetNode.getRight());
    3、删除有两个子节点的节点
    算法：这个逻辑相对来说较简单，就是找到该节点的左子树中的最大值或者右子树中的最小值，然后替换该节点的data，然后利用我们写的函数删除这个最大值或者最小值所对应的节点。
    这里我们假设要删除70
    删除70
    我们直接找到左子树的最大值60或者右子树的最大值80，对目标节点进行替换，然后删除该节点即可。

二叉树的内容比较多，大家一起学习，Fighting！！！

print HelloWorld
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java集合 TreeSet实现详解
奔跑的蜗牛
05-14 971
TreeSet实现详解 TreeSet是SortedSet接口的实现类，所以可以看出TreeSet是有序的。 与HashSet集合采用hash算法来决定元素的存储位置不同，TreeSet采用红黑树的数据结构来存储集合元素，那么TreeSet进行排序的规则是怎样的？TreeSet支持两种排序：自然排序和定制排序。 1、自然排序 TreeSet会调用集合元素的compareTo(Object obj)...
Java TreeSet集合
qq_45858803的博客
11-27 101
Java TreeSet集合 TreeSet集合实现了SortedSet接口, 可以对集合中元素进行自然排序, 要求集合中的元素必须是可比较的。 package Collection; import java.util.Comparator; import java.util.Objects; import java.util.TreeSet; /** * TreeSet集合 * 可以对元素进行自然排序, 要求元素必须是可比较的 * 1)创建TreeSet集合时,通过构造方法指定Comp
Java-TreeSet集合
weixin_48370579的博客
04-03 132
1.直接上代码， package com.shujia.wyh.day21; import java.util.TreeSet; /* 使用TreeSet存储自定义学生对象，并且使用比较器排序，使学生按照年龄长短进行排序 */ public class TreeSetDemo1 { public static void main(String[] args) { ...
Java集合中的TreeSet实现类(2022.5.26)
weixin_66262328的博客
05-26 139
我又来了呀！
Java集合中TreeSet的实现原理
飞龙在天
11-29 1877
Java集合中TreeSet的实现原理
javaTreeSet实现图书管理系统
07-29
在这个“javaTreeSet实现图书管理系统”中，我们可以利用`TreeSet`的特性来构建高效且功能完备的图书馆管理软件。下面将详细介绍如何利用`TreeSet`实现上述描述的功能。 1. **描述一个图书馆** 图书馆的基本信息...
java集合-TreeSet的使用
06-14
TreeSet 是 Java 中的一个集合类，它实现了 SortedSet 接口，并且使用红黑树作为底层数据结构。TreeSet 具有以下主要特点： 排序性：TreeSet 中的元素是有序的，默认按照元素的自然顺序进行排序。或者，可以在创建 ...
java中treemap和treeset实现红黑树
08-28
Java 中的 TreeMap 和 TreeSet 都是基于红黑树的数据结构实现的，TreeMap 负责维持元素的顺序，而TreeSet 负责提供Set集合的操作接口。红黑树的自平衡性使得 TreeMap 和 TreeSet 都能提供高效的Map和Set集合操作。
Java-Java集合教程
最新发布
11-13
Java集合框架是Java编程语言中一个非常重要的组成部分，它提供了数据结构和算法的实现，使得在处理对象集合时更加高效和灵活。Java集合教程通常会涵盖以下关键知识点： 1. **集合接口**： - `Collection`：这是...
Java + 集合 + TreeSet +定制排序
08-27
Java是全球排名第一的编程语言，Java工程师也是市场需求最大的软件工程师。 从互联网到企业平台，Java是应用最广泛的编程语言. Java是基于JVM虚拟机的跨平台语言，一次编写，到处运行； Java程序易于编写，而且有...
Java: TreeSet
lahhass的博客
02-25 402
树集是一个有序集合，在对集合进行遍历时，每个值自动排序后呈现 排序使用的结构是红黑树，添加元素时都被放置在正确的排序位置上 若树包含n个元素，查找新元素正确位置平均需要logn次比较 要使用树集，必须要能够比较元素，元素必须实现Comparable接口，或构造集时提供一个Comparator public class Test { public static void main(String[]...
Java集合类Treeset实现细节
StudyForDream2015的博客
04-22 476
一、TreeSet定义 TreeSet同样是基于TreeMap实现的，我们知道TreeMap是一个有序的二叉树，那么同理TreeSet同样也是一个有序的，它的作用是提供有序的Set集合。通过源码我们知道TreeSet基础AbstractSet，实现NavigableSet、Cloneable、Serializable接口。其中AbstractSet提供 Set 接口的骨干实现，从而最大限度地
java中 tree set_如何在Java中实现TreeSet？
weixin_39721370的博客
02-24 73
我正在实现一个TreeSet，它将按照人的年龄进行排序，但如果人的名字是平等的，那么一个人将不会被保存在集合中。我实现了equals和hashcode，但是这个集合将保存所有人，即使他们有相同的名字。我不知道为什么。public class Person implements Comparable{private String name;private int age;public Person(...
java treeset集合_java中的TreeSet集合
weixin_32063439的博客
02-16 138
package com.atguigujaav2;import java.util.Collection;import java.util.Iterator;import java.util.TreeSet;/*** TreeSet实现了Set接口的子接口SortedSet,基本特征和HashSet类一样，* 只是增加了排序功能。* */public class TestTreeSet {publ...
Java中TreeMap和TreeSet的底层实现
神奇女侠666的博客
07-02 5322
TreeSet底层则采用NavigableMap这个接口来保存TreeSet集合，而实际上NavigableMap只是一个接口，实际上TreeSet还是用TreeMap来保存set元素。 TreeSet初始化的时候会new 一个TreeMap进行初始化； private transient NavigableMap&lt;E,Object&gt; m; TreeSet(NavigableMa...
Java集合 TreeSet源码
思变的博客
12-20 158
1.TreeSet说明： (1)元素不能重复。 (2)具有排序功能。 (3)TreeSet中的元素必须实现Comparable接口并重写compareTo()方法（或者通过TreeSet的构造函数指定一个自定义的比较器） 2.TreeSet源码分析： 构造器传入自定义的比较器Comparator public TreeMap(Comparator<? super K> comparator) { this.comparator = comparator; } //value=PRES
java中的集合类：List、Set(TreeSet和HushSet)、Map
阿也的博客
04-01 330
Set和List都是Collection接口下的，实现了这个接口，这个接口中的功能有add()、remove()、isEmpty()、iterator()、size()等。 1.其中List下面又分为：ArrayList和LinkedList,就像它的名字一般一个内部以数组的形式实现，另一个以链表的形式实现，分别在各自的领域有着应用。 2. 其中Set又分为TreeSet和HushSet，TreeSet是排好序的。 3. 自己去定义的时候在最右边一定是最底层的数据类型，不能是Set或者是List，那样你会需
Java 集合 TreeSet 详解
m0_51517626的博客
08-15 261
TreeSet TreeSet底层使用红黑树进行存储,可以按照插入对象的属性进行排序 要求,插入的对象,必须要是相同的类,否则会报错 报错的原因: **因为在Set本身是用于存储无序的,不重复的元素,在HashSet和LinkedHashSet中使用equals()+hashCode()的方式进行判断,而对于TreeSet,因为其可以实现对插入对象的属性进行比较,所以插入的对象必须实现Comparable接口(自然排序)或在定义TreeSet时通过构造器填入Comparator接口的实现对象(定制排序)。所
【Java基础】023 -- 集合进阶（List、Set、泛型、树）
汤姆lazy的CSDN博客
02-18 1580
Java集合进阶，内容包括：集合体系结构、Collecton集合基本介绍、LIst集合、ArrayList集合、LinkedList集合、常见的数据结构、泛型深入、树、Set系列集合、HashSet、LinkedHashSet、TreeSet、综合案例和使用场景、源码分析。
Java遍历TreeSet集合数据
05-25
可以使用迭代器（Iterator）或者for-each循环来遍历TreeSet集合数据。下面是两种方式的示例代码： 1. 使用迭代器遍历TreeSet集合数据： ```java TreeSet<String> set = new TreeSet(); set.add("apple"); set.add...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值