二分搜索树的一些总结以及代码实现（java实现）

最新推荐文章于 2022-12-29 07:30:00 发布
最新推荐文章于 2022-12-29 07:30:00 发布
阅读量753 收藏
点赞数
分类专栏： 数据结构和算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42405666/article/details/89162756
版权

概念

  • 二分搜索树：对有一个树的任何结点，其右子树的值总是大于当前结点的值，
  • 其左子树的值总是小于当前结点的值。
  • 注意：线性表，队列，栈都可以存重复元素，树最好不要存。
  • 功能实现
  • 1.判断当前树的长度
  • 2.判断当前树是否为空
  • 3.给树添加元素，两种实现方法，一种是迭代法，一种是递归。
  • 4.查找元素是否包含在树种
  • 5.中序遍历
  • 6.广度优先遍历（队列实现）
  • 7.获取最小值
  • 8.获取最大值
  • 9.删除最小值结点
  • 10。删除最大值结点
  • 11.删除指定元素。
  • 12.打印这个树。重写tostring
  • 13.二叉搜索树迭代器

代码实现

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/*
 * 二分搜索树：对有一个树的任何结点，其右子树的值总是大于当前结点的值，
 * 其左子树的值总是小于当前结点的值。
 * 注意：线性表，队列，栈都可以存重复元素，树最好不要存。
 * 功能实现 1.判断当前树的长度 
 * 2.判断当前树是否为空 
 * 3.给树添加元素，两种实现方法，一种是迭代法，一种是递归。 
 * 4.查找元素是否包含在树种
 * 5.中序遍历
 * 6.广度优先遍历（队列实现）
 * 7.获取最小值
 * 8.获取最大值
 * 9.删除最小值结点
 * 10。删除最大值结点
 * 11.删除指定元素。
 * 12.打印这个树。重写tostring
 */
public class BinarySearchTree<E extends Comparable<E>> {
	/*
	 * 定义结点
	 */
	private class Node {
		public E e;
		public Node left, right;

		public Node(E e) {// 初始化Node
			this.e = e;
			this.left = null;
			this.right = null;
		}
	}

	/*
	 * 定义二叉树的根结点和长度
	 */
	public Node root;
	public int size;

	public BinarySearchTree() {
		this.root = null;
		size = 0;
	}

	/*
	 * 功能实现 1.判断当前树的长度 2.判断当前树是否为空 3.给树添加元素，两种实现方法，一种是迭代法，一种是递归。 4.查找元素是否包含在树种
	 */
	public int size() {// 1.
		return size;
	}

	public boolean isempty() {// 2.
		return size() == 0;
	}

	public void add(E e) {//3.
		// 迭代实现
		/*
		 * if(root==null) { Node n=new Node(e); root=n; size++; } Node p=root;//
		 * while(true) { //先判断重复元素 if(e.compareTo(p.e)==0) {//树种的结点依次和传入的e进行比较 return;
		 * }else if(e.compareTo(p.e)>0) { if(p.right!=null) { p=p.right; }else {
		 * p.right=new Node(e); size++; return; } }else { if(p.left!=null) { p=p.left;
		 * }else { p.left=new Node(e); size++; return; } } }
		 */
		// 递归实现
		root = add(root, e);
	}

	private BinarySearchTree<E>.Node add(BinarySearchTree<E>.Node node, E e) {
		// TODO Auto-generated method stub
		if(node==null) {
			size++;
			return new Node(e);
		}
		if (e.compareTo(node.e) > 0) {
			node.right = add(node.right, e);
		} else if (e.compareTo(node.e) < 0) {
			node.left = add(node.left, e);
		}
		return node;
	}
	public boolean contains(E e) {//4.
		//迭代
		/*if(root==null) {
			return false;
		}
		Node p=root;
		while(true) {
			if(p==null) {
				break;
			}
			if(e.compareTo(p.e)>0) {
				p=p.right;
			}else if(e.compareTo(p.e)<0) {
				p=p.left;
			}else {
				return true;
			}
		}
		return false;
	}*/
		//递归
		return contains(root,e);
}

	private boolean contains(BinarySearchTree<E>.Node node, E e) {
		// TODO Auto-generated method stub
		if(node==null) {
			return false;
		}
		if(e.compareTo(node.e)>0) {
			return contains(node.right,e);
		}else if(e.compareTo(node.e)<0){
			return contains(node.left,e);
		}else {
			return true;
		}
	}
	public void inOrder() {//左右中
		/*
		 * 将遍历的结果存到List中
		 *
		 */
		List list=new ArrayList<E>();
		inOrder(root,list);
		System.out.println(list);
	}

	private void inOrder(BinarySearchTree<E>.Node node, List list) {
		// TODO Auto-generated method stub
		if(node==null) {
			return;
		}
		inOrder(node.left,list);
		list.add(node.e);
		inOrder(node.right,list);
	}
	public void levelOrder() {//广度优先遍历 也叫层序遍历
		ArrayList<E> list = new ArrayList<E>();
		// 用辅助队列实现层序遍历 
		Queue<Node> queue = new LinkedList<Node>();
		queue.add(root);
		while (!queue.isEmpty()) {
			Node cur = queue.poll();//出队
			list.add(cur.e);
			if (cur.left != null) {//出队的时候将当前结点的左右孩子结点添加进来
				queue.add(cur.left);
			}
			if (cur.right != null) {
				queue.add(cur.right);
			}
		}
		System.out.println(list);
	}
	//7获取最小值
	public E min() {
		if(size==0) {
			throw new IllegalArgumentException("空树");
		}
		return min(root).e;
	}

	private Node min(Node node) {
		// TODO Auto-generated method stub
		if(node.left==null) {
			return node;
		}
		return min(node.left);
	}
	//8.获取最大值
	public E max() {
		if(size==0) {
			throw new IllegalArgumentException("空树");
		}
		return max(root).e;
	}

	private Node max(Node node) {
		// TODO Auto-generated method stub
		if(node.right==null) {
			return node;
		}
		return max(node.right);
	}
	//9.删除最小值结点
	public E removemin() {
		E e=min();
		root=removemin(root);//删除后返回新的根结点
		return e;
	}

	private Node removemin(Node node) {
		// TODO Auto-generated method stub
		if(node.left==null) {
			Node rightnode=node.right;
			node.right=null;
			size--;
			return rightnode;
		}
		node.left=removemin(node.left);
		return node;
	}
	//10.删除最大值结点,并返回删除后的值。
	public E removemax() {
		E e=max();
		root=removemax(root);
		return e;
	}

	private Node removemax(Node node) {
		// TODO Auto-generated method stub
		if(node.right==null) {
			Node leftnode=node.left;
			node.left=null;
			size--;
			return leftnode;
		}
		node.right=removemax(node.right);
		return node;
	}
	//11.删除指定的元素
	//如果二叉树为空树或者找不到这个元素，就返回空
	public void remove(E e) {
		root=remove(root,e);
	}

	private Node remove(Node node, E e) {
		// TODO Auto-generated method stub
		if(node==null) {
			return null;
		}
		if(e.compareTo(node.e)>0) {//如果删除的值比当前结点的值大
			node.right=remove(node.right, e);
			return node;//这里的node一直返回给头
		}else if(e.compareTo(node.e)<0) {
			node.left=remove(node.left, e);
			return node;
		}else {//等于
			if(node.left==null) {
				Node rightnode=node.right;
				node.right=null;
				size--;
				return rightnode;//返会给删除的上一个结点
			}if(node.right==null) {
				Node leftnode=node.left;
				node.left=null;
				size--;
				return leftnode;
			}
			//如果这个结点的左右孩子结点都不为空
			Node temp=min(node.right);//找到当前结点右子树中最小的结点
			temp.right=removemin(node.right);//当前结点中的最小结点，如果不删，则会重复。
			temp.left=node.left;
			node.left=node.right=null;
			return temp;
		}
	}
	//12
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		StringBuilder sb=new StringBuilder();
		BSTlterator bs=new BSTlterator(root);
		while(bs.hasnext()) {
			sb.append(bs.next()+"\n");
		}
		//print(root,0,sb);
		return sb.toString();
	}

	private void print(Node node, int level, StringBuilder sb) {
		// TODO Auto-generated method stub
		/*
		 * 空子树用null代替
		 */
		if(node==null) {
			sb.append(printlevel(level)+"00\n");
		}else {
			//中序遍历打印  左中右
			
			print(node.left,level+1,sb);
			sb.append(printlevel(level)+node.e+"\n");
			print(node.right,level+1,sb);
		}
	}

	private String printlevel(int level) {
		// TODO Auto-generated method stub
		StringBuilder sb2=new StringBuilder();
		for(int i=0;i<level;i++) {
			sb2.append("  ");
		}
		return sb2.toString();
	}
	//13----------------------二叉搜索树迭代器-----------------
	//迭代器的实现其实和中序遍历一样，都是从小到大打印
	/*
	 * 只不过中序遍历是用递归是用递归实现，当数据量成千上万时，容易造成栈溢出。
	 */
	class BSTlterator{
		LinkedList<Node> stack=new LinkedList<>();
		public BSTlterator(Node root) {
			// TODO Auto-generated constructor stub
			Node cur=root;
			while(cur!=null) {
				stack.push(cur);
				cur=cur.left;
			}	
		}
		public E next() {
			Node n=stack.pop();
			Node cur=n.right;
			while(cur!=null) {
				stack.push(cur);
				cur=cur.left;
			}
			return n.e;
		}
		public boolean hasnext() {
			return !stack.isEmpty();
		}
	}
}

二分搜索树的时间复杂度为O(log(2,n))

奔跑的乌龟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】二分搜索树小结
offer！
04-07 298
一、基本概念 二分搜索树:（又：二分查找树，二叉排序树）它或者是一棵空树，或者是具有下列性质： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。 ...
【数据结构】二分搜索树
m0_50987960的博客
12-05 1366
自己创建的二叉搜索树的各种方法
java实现二分查树_简单用Java实现二分搜索树
weixin_34521244的博客
02-27 200
二叉树由节点(Node)组成，每个节点包含一个“左”指针(left)、“右”指针(right)和一个数据元素(e)。“根”(root)指针指向树中最顶端的节点。左右指针递归地指向较小的两边的“子树”。空指针表示没有元素的二叉树——空树。正式的递归定义是：二叉树要么为空(由空指针表示)，要么由单个节点构成，其中左指针和右指针(前面是递归定义)都指向一个二叉树。上图是一棵二分搜索树(BST)：二分搜索...
Java中的二分搜索树
XHT117的博客
05-23 439
二分搜索树 基础操作 1. 向BST中添加一个节点 2. 判断val是否在BST中存在contains 3. 按照先序遍历的方式打印当前的BST 4. 找到一颗BST的最大值和最小值 5. 删除最大值和最小值 6. 删除任意值val
Java数据结构-二分搜索树的实现
qq_44297579的博客
07-14 219
二分搜索树是一种特殊的二叉树，以放整型数据为例，左子树放的元素都比根小，右子树的元素都比根大，所以在查询时效率是非常高的。需要利用二分搜索树进行存储时要求存储的对象是可比较的，所以需要继承Comparable接口。接下来看下实现二分搜索树所需要的方法： BST()无参构造 size()返回二分搜索树的元素个数 isEmpty()判断是否为空 add(E e)用户当使用这个二分搜索树时调用的添加元素的方法 add(Node node,E e)实际添加元素的方法，传入需要添加元素的根节点和添加的元素 conta
二分搜索树（JAVA）
cedarjo的博客
04-18 323
先放代码 public class BST<E extends Comparable<E>> { private class Node<E> { public E val; public Node<E> left, right; public Node(E e) { ...
Java二叉搜索树基础原理与实现方法详解
08-19
//二分搜索树存储元素是否为空 public boolean isEmpty() { return size == 0; } ... } ``` 本文详细介绍了Java二叉搜索树的基础原理与实现方法，涵盖了二叉树的定义、特点、二叉搜索树的定义、性质、思想、...
最优二分搜索树（动态规划）
11-17
设S=(x1,x2,…,xn)是有序集，且x1…，已知键值和区间的存取概率分布为(a0,b1,a1,b2,…,bn,an)，其中ai表示相应区间的搜索概率，bi表示相应键值的...在所有表示有序集的二叉树中找出一棵具有最小平均路长的二叉搜索树
如何用 java 实现【二叉搜索树】
最新发布
超烦豆先森
12-29 1043
关于数据结构 二叉搜索树的 java 实现
Java实现二分搜索树
weixin_43388149的博客
07-27 598
Java实现二分搜索树二分搜索树的定义二分搜索树的代码结构向二分搜索树添加元素（递归实现）对添加元素代码的简化（如果递归功底深厚）查看二分搜索树中是否还有元素e（递归）二分搜索树的前序遍历（递归）基于前序遍历重写toString二分搜索树的中序遍历二分搜索树的后序遍历二分搜索树的前序遍历（非递归）二分搜索树的层序遍历（非递归）（广度优先遍历）查找二分搜索树中的最大最小值删除二分搜索树的最小值与最大...
手把手教你用java实现二分查找树及其相关操作
hookind's blogs
07-26 380
二分查找树（Binary Search Tree）的基本操作有搜索、求最大值、求最小值、求前继、求后继、插入及删除。 对二分查找树的进行基本操作所花费的时间与树的高度成比例。例如有n个节点的完全二叉树，对它进行的基本操作的时间复杂度为O(logn)。然而，如果树是一个有n个节点的线性的链，则在这种情况下的时间复杂度为O(n)。 1、什么是二分查找树 二分查找树是一种有组织的二叉树。我们可以通过链接节点表示这样一棵树。每个节点包含键（key），数据（data），左子节点（left），右子节点（right），父
Java 二分搜索树实现 - 完整代码
爱干饭的猿的博客
03-16 1434
目录 1.二分搜索树: 1.1 概念 1.2 重点操作 1.3 完整代码 1.二分搜索树: 1.1 概念 a.是个二叉树(每个节点最多有两个子节点) b.对于这棵树中的节点的节点值 左子树中的所有节点值 < 根节点 < 右子树的所有节点值 二分搜索树中一般不考虑值相等的情况(元素不重复)JDK中的搜索树就不存在相同的值(TreeMap-key) 最大特点:也是判断是否是搜索树的方法 对该树进行中序遍历，就可以得到一个升序集合0 1 2 3 4 5 6 7 8
二叉树的概念、性质，以及用使用Java语言实现二分搜索树
hoji_James的博客
06-11 500
1.什么是二叉树 在计算机科学中，二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。   2.二叉树的性质 (1)二叉树具有唯一根结点 (2)二叉树中每个结点多只有2个孩子 (3)二叉树每个结点最多只有一个父节点 (4)二叉树具有天然递归结构，表现为：        ①每个节点的左子树(若存在...
Java数据结构之二分搜索树(BST)
qq15035899256的博客
08-05 709
本文是Java数据结构的学习，认识了BST树，BST树的插入和删除操作，以及BST树的不平衡性。之后的学习内容将持续更新！！！
java实现二分搜索树
ly853602的博客
06-27 134
二分搜索树的特点 1.二分搜索树的每一个节点的值大于其左子树的所有节点的值,并且小于其右子树的所有节点的值 2.每一颗子树也是二分搜索树 3.因为它的存储是有序的，存储的元素必须具有可比较性 树结构的遍历方法 前序遍历：先遍历根结点，再遍历左子树，最后遍历右子树。 中序遍历：先遍历左子树，再遍历根结点，最后遍历右子树，遍历结果从小到大有序排列 后序遍历：先遍历左子树，再遍历右子...
二分搜索树（二叉排序树）Java实现
宋七夏的博客
05-03 440
二分搜索树（二叉查找树） ​ 参考：《数据结构与算法分析》和《算法（第四版）》 特性 ​ 二分搜索树（Binary Search Tree，BST，后面全用BST代替）也可叫做二叉查找树。它不仅可以查找数据，还可以高效地插入、删除数据。 ​ 特性: 若任意节点的左子树不空，则左子树上所有节点的值均小于它的根节点的值； 若任意节点的右子树不空，则右子树上所有节点的值均大于它的根节点的值； ...
Java实现简单搜索引擎：代码与逻辑详解
此外，为了优化，可以考虑使用更高效的搜索算法，例如二分查找、Trie树等，尤其是当数据量大或者需要支持模糊查询时。不过，这超出了给定内容的范围，但可以作为一个高级话题进一步探讨。 总结起来，Java实现简单的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值