详谈二叉搜索树

最新推荐文章于 2024-07-22 19:36:52 发布
最新推荐文章于 2024-07-22 19:36:52 发布
阅读量89 收藏 1
点赞数 3
分类专栏： 数据结构与算法 文章标签： 数据结构 二叉树 stack 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cout_s/article/details/119329730
版权

详谈二分搜索树

在这里插入图片描述

二分搜索树的概念

在了解二分搜索树之前，我们得弄清楚什么是二叉树。

什么是二叉树？

在这里插入图片描述

二分搜索树

在这里插入图片描述

二分搜索树的创建以及实现其方法

1.内部结构

内部有一个结点类，作为二分搜索树的成员变量使用

private class Node{
        public E e;//结点元素
        public Node left,right;//左右结点
        public Node (E e){//初始化
            this.e = e;
            left = null;
            right = null;
        }
        public  String toString(){
            return e.toString();
        }
    }
2.构造方法与成员变量

初始化成员变量

    private Node root;//根节点
    private int size;//有效结点个数
    public BinarySearchTree(){//构造方法
        size =0;
        root = null;
    }
3.增添元素

根据元素值大小决定去向，小于父亲节点在左边，大于在右边

 public int size(){//获取有效长度
        return size;
    }
    public boolean isEmpty(){//判断是否为空
        return size==0&&root==null;
    }
    public void clear(){
        size =0;
        root = null;
    }
    public void add(E e){增添元素
        root = add(root,e);//在根节点的基础上去添加
    }
    private Node add(Node node,E e){
        if(node==null){
            size++;
            return  new Node(e);
        }
        if(e.compareTo(node.e)>0){//e大于父节点的值
            node.right = add(node.right,e);
        }else if(e.compareTo(node.e)<0){
            node.left = add(node.left,e);
        }else {
            node.e = e;
        }
        return node;
    }
4.遍历元素

遍历元素总共有四种种先序、后序、中序和层次遍历。

private void preOrderNR(){//先序非递归遍历
        Stack<Node> stack = new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            Node node = stack.pop();
            System.out.print(node.e+"  ");
            if (node.right!=null){//利用栈先入右节点，在入左节点  先进后出 后进先出
                stack.push(node.right);
            } if(node.left!=null){
                stack.push(node.left);
            }

        }

    }
    private void preOrder(Node node){//先序递归遍历
        if(node == null){
            return;
        }
        System.out.print(node.e+"  ");
        preOrder(node.left);
        preOrder(node.right);
    }
    public void inOrder(){
            inOrder(root);
        System.out.println("=========");
            inOrderNR();
    }
    public void inOrder(Node node){//中序递归遍历
        if(node==null){
            return;
        }
        inOrder(node.left);
        System.out.print(node.e+"  ");
        inOrder(node.right);
    }
    public void inOrderNR(){//中序非递归遍历
        Stack<Node> stack = new Stack();
        Node p =root;
        while(p!=null){
            stack.push(p);
            p = p.left;
        }
        while(!stack.isEmpty()){
            Node ret = stack.pop();
            System.out.print(ret.e+"  ");
            if(ret.right!=null){
                p = ret.right;
                while(p!=null){
                    stack.push(p);
                    p = p.left;
                }
            }
        }
    }
    public void postOrder(){
        postOrder(root);
        System.out.println();
        postOrderNR();
    }
     private void postOrder(Node node){//后序递归遍历
        if(node == null){
            return ;
        }
        postOrder(node.left);
        postOrder(node.right);
        System.out.print(node.e+"  ");
    }
    private void postOrderNR() {//后序非递归遍历
        Stack<Node> stack = new Stack<>();
        Node node = root;
        Node pre = null;
        while(!stack.isEmpty()||node!=null){
            while (node!=null){
                stack.push(node);
                node = node.left;
            }
            if (!stack.isEmpty()){
                node = stack.pop();
                if(node.right==null||pre==node.right){
                    System.out.print(node.e+"  ");
                    pre = node;
                    node =null;
                }else{
                    stack.push(node);
                    node = node.right;
                }
            }

        }
    }
    public void levelOrder(){//层序遍历
         Queue<Node> que = new LinkedList<>();
         que.add(root);
         while(!que.isEmpty()){
             Node e = que.poll();
             System.out.print(e.e);
             if(e.left!=null){
                 que.add(e.left);
             }
             if(e.right!=null){
                 que.add(e.right);
             }
         }
    }
5.判断元素是否存在

目的是为了判断一个元素是否在二分查找树中

 public boolean contains(E e){

        return contains(root,e);
    }
    private boolean contains(Node node,E e){
        if(node == null){
            return false;
        }
        if(e.compareTo(node.e)==0){
            return true;
        }
        return e.compareTo(node.e)>0 ? contains(node.right,e):contains(node.left,e);
    }
6.remove移除一个结点

删除一个结点及元素值

public void remove(E e){
        root = remove(root,e);
    }
    public Node remove(Node node,E e){
        if(node==null){
            return null;
        }
        if(e.compareTo(node.e)>0){
            node.right = remove(node.right,e);
        }else if(e.compareTo(node.e)<0){
            node.left = remove(node.left,e);
        }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 successor = minimun(minimun(node.right));
            successor.right = removemin(node.right);
            successor.left = node.left;
            node.left =null;
            node.right = null;
            size--;
            return  successor;
        }
        return null;
    }

最终整体代码

package com.数据结构.xiaoniu.类;

import com.sun.org.apache.xalan.internal.xsltc.compiler.util.StringStack;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class BinarySearchTree<E extends Comparable<E>> implements Iterable{
    private class Node{
        public E e;
        public Node left,right;
        public Node (E e){
            this.e = e;
            left = null;
            right = null;
        }
        public  String toString(){
            return e.toString();
        }
    }
    private Node root;
    private int size;
    public BinarySearchTree(){
        size =0;
        root = null;
    }
    public int size(){
        return size;
    }
    public boolean isEmpty(){
        return size==0&&root==null;
    }
    public void clear(){
        size =0;
        root = null;
    }
    public void add(E e){

        root = add(root,e);
    }
    private Node add(Node node,E e){
        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);
        }else {
            node.e = e;
        }
        return node;
    }
    public boolean contains(E e){

        return contains(root,e);
    }
    private boolean contains(Node node,E e){
        if(node == null){
            return false;
        }
        if(e.compareTo(node.e)==0){
            return true;
        }
        return e.compareTo(node.e)>0 ? contains(node.right,e):contains(node.left,e);
    }
    public void preOrder(){
       preOrder(root);
        System.out.println();
       preOrderNR();

    }
    private void preOrderNR(){
        Stack<Node> stack = new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            Node node = stack.pop();
            System.out.print(node.e+"  ");
            if (node.right!=null){//利用栈先入右节点，在入左节点  先进后出 后进先出
                stack.push(node.right);
            } if(node.left!=null){
                stack.push(node.left);
            }

        }

    }
    private void preOrder(Node node){
        if(node == null){
            return;
        }
        System.out.print(node.e+"  ");
        preOrder(node.left);
        preOrder(node.right);
    }
    public void inOrder(){
            inOrder(root);
        System.out.println("=========");
            inOrderNR();
    }
    public void inOrder(Node node){
        if(node==null){
            return;
        }
        inOrder(node.left);
        System.out.print(node.e+"  ");
        inOrder(node.right);
    }
    public void inOrderNR(){
        Stack<Node> stack = new Stack();
        Node p =root;
        while(p!=null){
            stack.push(p);
            p = p.left;
        }
        while(!stack.isEmpty()){
            Node ret = stack.pop();
            System.out.print(ret.e+"  ");
            if(ret.right!=null){
                p = ret.right;
                while(p!=null){
                    stack.push(p);
                    p = p.left;
                }
            }
        }
    }
    public void postOrder(){
        postOrder(root);
        System.out.println();
        postOrderNR();
    }

    private void postOrderNR() {
        Stack<Node> stack = new Stack<>();
        Node node = root;
        Node pre = null;
        while(!stack.isEmpty()||node!=null){
            while (node!=null){
                stack.push(node);
                node = node.left;
            }
            if (!stack.isEmpty()){
                node = stack.pop();
                if(node.right==null||pre==node.right){
                    System.out.print(node.e+"  ");
                    pre = node;
                    node =null;
                }else{
                    stack.push(node);
                    node = node.right;
                }
            }

        }
    }
    public void levelOrder(){//层序遍历
         Queue<Node> que = new LinkedList<>();
         que.add(root);
         while(!que.isEmpty()){
             Node e = que.poll();
             System.out.print(e.e);
             if(e.left!=null){
                 que.add(e.left);
             }
             if(e.right!=null){
                 que.add(e.right);
             }
         }
    }
    public E minimum(){
        if(size==0){
            throw new IllegalArgumentException("Is NULL!");
        }
        Node n = root;
        while (n.left!=null){
            n=n.left;
        }
        return n.e;
    }
    public E maxmun(){
        if(size==0){
            throw new IllegalArgumentException("Is NULL!");
        }
        Node n = root;
        while (n.right!=null){
            n=n.right;
        }
        return n.e;
    }
    public E removeMin(){//删除最小二叉树中的节点
        if(size==0){
            throw new IllegalArgumentException("Is NULL!");
        }
        Node n = root;
        while (n.left.left!=null){
            n=n.left;
        }
        E ret = n.left.e;
        n.left = n.left.right;
        return ret;
    }
    public E removeMax(){
        if(size==0){
            throw new IllegalArgumentException("Is NULL!");
        }
        Node n = root;
        while (n.right.right!=null){
            n=n.right;
        }
        E ret = n.right.e;
        n.right = n.right.left;
        return ret;
    }
    public E removemin(){
        E ret = minimum();
        root = removemin(root);
        return ret;
    }
    public E removemax(){
        E ret = maxmun();
        root = removemax(root);
        return ret;
    }
    private Node removemax(Node node){
        if(node.right==null){
            Node leftNode = node.left;
            node.left = null;
            size--;
            return leftNode;
        }
        node = node.right;
        node.right = removemax(node.right);
        return node;
    }
    public Node removemin(Node node){
        if(node.left==null){
            Node rightNode = node.right;
            node.right = null;
            size--;
            return rightNode;
        }
        node.left = removemin(node.left);
        return node;
    }

    public Node minimun(Node node){
        if(node.left==null){
            return node;
        }
        return minimun(node.left);
    }
    public Node maximum(Node node){
        if(node.right==null){
            return node;
        }
        return minimun(node.right);
    }
    public void remove(E e){
        root = remove(root,e);
    }
    public Node remove(Node node,E e){
        if(node==null){
            return null;
        }
        if(e.compareTo(node.e)>0){
            node.right = remove(node.right,e);
        }else if(e.compareTo(node.e)<0){
            node.left = remove(node.left,e);
        }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 successor = minimun(minimun(node.right));
            successor.right = removemin(node.right);
            successor.left = node.left;
            node.left =null;
            node.right = null;
            size--;
            return  successor;
        }
        return null;
    }
    private void postOrder(Node node){
        if(node == null){
            return ;
        }
        postOrder(node.left);
        postOrder(node.right);
        System.out.print(node.e+"  ");
    }
    public String toString(){
        StringBuilder res =new StringBuilder();
        gennerateBSTString(root,0,res);
        return res.toString();
    }

    private void gennerateBSTString(Node node, int depth, StringBuilder res) {
        if(node==null){
            res.append(generateDepthString(depth)+node.e+"\n");
            return;
        }
        res.append(generateDepthString(depth)+node.e+"\n");
        gennerateBSTString(node.left,depth+1,res);
        gennerateBSTString(node.right,depth+1,res);
    }

    private String generateDepthString(int depth) {
        StringBuilder sb =new StringBuilder();
        for(int i=0;i<depth;i++){
            sb.append("--");
        }
        return  sb.toString();
    }

    @Override
    public Iterator<E> iterator() {
        return new BinarySearchTreeIterator();
    }
    private class BinarySearchTreeIterator implements Iterator<E>{
        private LinkedList<Node> list = new LinkedList<>();
        public BinarySearchTreeIterator(){
            Stack<Node> stack = new Stack<>();
            Node p = root;
            while(p!=null){
                stack.push(p);
                p =p.left;
            }
            while (!stack.isEmpty()){
                Node n = stack.pop();
                list.add(n);
                if(n.right!=null){
                    p = n.right;
                    while(p!=null){
                        stack.push(p);
                        p = p.left;
                    }
                }
            }
        }
        @Override
        public boolean hasNext() {
            return !list.isEmpty();
        }

        @Override
        public E next() {

            return (E) list.removeFirst();
        }
    }
}
牛牛最爱喝兽奶
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
详谈LTE关键技术
01-19
LTE（Long Term Evolution,长期演进）项目是3G的演进，始于2004年3GPP的多伦多会议。LTE并非人们普遍误解的4G技术，而是3G与4G技术之间的一个过渡，是3.9G的标准，它改进并增强了3G的空中接入技术，采用OFDM和MIMO...
示波器的触发设置详谈
01-20
“触发”称得上数字示波器灵魂级的概念，如果没有合适的触发条件，波形观测也无从谈起。虽然很多工程师熟悉触发功能，但只知其表不知其里。如何深入理解触发呢?这篇ZDS示波器研发笔记在这里分享给大家。...
php中目录,文件操作详谈
10-30
php中目录,文件操作详谈
详谈多摄像机目标跟踪系统
01-20
视频监控是安全防范系统的重要组成部分，它是一种防范能力较强的综合系统。视频监控以其直观、准确、及时和信息内容丰富而广泛应用于许多场合。近年来，随着计算机、网络以及图像处理、传输技术的飞速发展，视频监控...
Servlet详谈
05-12
Servlet解释的非常详细，非常给力，看看吧
详细理解中缀表达式并实现
cout_s的博客
07-17 7869
中缀表达式的实现及概念 中缀表达式的定义 中缀表达式是一个通用的算术或逻辑公式表示方法。
详细理解双端队列的实现及原理
cout_s的博客
07-20 4168
双端栈的实现原理及概念 双端栈的定义
详解双向循环链表的实现及概念
cout_s的博客
07-23 941
解剖双向循环链表！！！
全排列思路详解
cout_s的博客
08-03 564
详解全排列
ConcurrentHashMap1.7和ConcurrentHashMap1.8的异同
cout_s的博客
10-04 463
ConcurrentHashMap ConcurrentHashMap在与HashMap的不同之处在于多线程下更安全，而针对于Hashtable的基础上进行了一次升级。Hashtable的安全机制过于粗暴，导致性能很低。根据不同版本采用的方式也有不同。 public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V>, Serializable
用栈实现队列_LeetCode和队列实现栈
cout_s的博客
07-18 152
栈实现队列——LeetCode第232题
来咯老弟！拔，全排列+组合 = “排列“、子序列问题求解
cout_s的博客
09-25 120
一起学习呀，正经人呀 今天我要给大家解决的两个问题： 第一个全排列+组合类的相关问题 单单的全排列怎么能满足日常行走江湖的条件呢？通常很多时候都会遇见排列+组合的问题。其实老早在高中学习生涯里就遇到了排列组合的问题，不过那时候靠手计算，题目也不是很难。现在我们要让计算机来帮我们干这件事情！过多的介绍什么是全排列和组合就不细说了！排列的顺序可以颠倒，且不能选取重复的数据！而组合不看顺序，只看数据！ 全排列就是将所有数据打乱，然后就行排列，看有多少种排法。 而组合：C(n,m)只关系拿取的数据是否相同，存放位
通俗易懂的红黑树♥♥
cout_s的博客
08-10 114
红黑树的详情 红黑树是一种二叉查找树，形态和平衡二叉树类似，区别就在于红黑树的结点带有颜色。根节点通常为黑色。
计数，桶与基数排序
m0_68142120的博客
07-19 827
要进行 i(最高位的位数) 趟排序 ， 每趟排序需要将元素分派到k个桶，所以每趟排序的时间复杂度为O(n+k) 走i趟时间复杂度就为O(i(n+k)) 但桶的个数通常是固定的，执行的躺数一般又较小，所以基数排序的。如果待排序的元素数量很大，这可能会占用较多的内存空间。再次遍历待排序数组，对于数组中的每个元素，将其值减去最小值（为了使得计数数组的下标从0开始），并将计数数组中对应下标的值加1。如果待排序数组中的元素是负数，或者元素的取值范围较大，计数排序可能不适用，因为它需要额外的空间来存储计数数组。
数组算法--基本查找
2303_78660417的博客
07-20 393
基本查找就是从数组的0索引处开始，依次往后查找，如果找到了对应索引处的值，就会，如果没有找到。因为数组的索引号是没有-1的，当返回-1的时候，就能明白没有找到。
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1086
可以参考以下视频。
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 251
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
数据结构---二叉树
最新发布
weixin_47808575的博客
07-22 167
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
详谈pyaotowin的使用
03-28
Pyaotowin是一种基于Python的Windows渗透测试工具，它可以帮助安全从业人员进行Windows系统的渗透测试和漏洞利用。下面是Pyaotowin的详细使用说明： 1. 安装Pyaotowin Pyaotowin可以通过pip命令安装，命令如下： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

牛牛最爱喝兽奶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值