二叉排序树-java语言描述

最新推荐文章于 2022-11-15 21:58:49 发布
最新推荐文章于 2022-11-15 21:58:49 发布
阅读量175 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_44561426/article/details/122201198
版权

java 数据结构 二叉树

二叉排序树

1、概念

​ 对于二叉排序树的任何一个非叶子节点，当前节点的左节点小于当前节点，当前节点的右节点大于当前节点

​ 注意：如果有与当前节点相同的值的节点时，则该节点放在当前节点的左右节点都可以

2、对二叉排序树的操作
2.1、添加节点
	/**
     * 添加节点
     *
     * @param node 需要添加的值
     */
    public void add(Nodes node) {
        if (node == null) {
            return;
        }
        //判断传入的节点与当前节点的关系来决定如何插入
        if (node.getValue() < this.value) {
            //如果当前节点的左节点为空
            if (this.getLeft() == null) {
                this.setLeft(node);
            } else {
                this.getLeft().add(node);
            }
        } else {
            //如果当前节点的右节点为空
            if (this.getRight() == null) {
                this.setRight(node);
            } else {
                this.getRight().add(node);
            }
        }
    }
2.2、删除节点
	/**
     * 查找要删除的节点
     *
     * @param value 要查找的值
     * @return 返回被找到的值
     */
    public Nodes search(int value) {
        if (this.getValue() == value) {
            return this;
        } else if (this.getValue() > value) {     //向左子节点查找
            if (this.getLeft() == null) {
                return null;
            } else {
                //向左子树递归查找
                return this.getLeft().search(value);
            }
        } else {                                 //向右子节点查找
            if (this.getRight() == null) {
                return null;
            } else {
                //向右子树递归查找
                return this.getRight().search(value);
            }
        }
    }

    /**
     * 查找要删除节点的父节点
     *
     * @param value 要查找的节点的值
     * @return 返回被查找到的节点的父节点
     */
    public Nodes searchParent(int value) {
        //当前节点的子节点就是要删除的节点
        if ((this.getLeft() != null && this.getLeft().getValue() == value) ||
                (this.getRight() != null && this.getRight().getValue() == value)) {
            return this;
        } else {
            //当前节点的值大于value，且当前节点的左节点不为空
            if (this.getValue() > value && this.getLeft() != null) {
                return this.getLeft().searchParent(value);
                //当前节点的值小于value，且当前节点的右节点不为空
            } else if (this.getValue() < value && this.getRight() != null) {
                return this.getRight().searchParent(value);
                //没有找到符合条件的
            } else {
                return null;
            }
        }
    }

    /**
     * @param nodes 传入的节点当作该二叉树的根节点
     * @return 返回以 nodes为根节点的二叉排序树的最小节点的值
     */
    public int treeMin(Nodes nodes) {
        Nodes target = nodes;
        //循环查找左子节点
        while (target.getLeft() != null) {
            target = target.getLeft();
        }
        //删除这个值最小的节点
        deleteNode(target.getValue());
        return target.getValue();
    }

	//删除节点
    public void deleteNode(int value) {
        if (root == null) {
            return;
        } else {
            //1、先找到需要删除的节点
            Nodes target = search(value);

            //如果没找到需要删除的节点
            if (target == null) {
                return;
            }
            //只有一个节点
            if (root.getLeft() == null && root.getRight() == null) {
                root = null;
                return;
            }

            //2、找到需要删除节点的父节点
            Nodes parent = searchParent(value);

            //判断要删除的节点位于该二叉树的哪个位置
            //1、要删除的节点是叶子节点
            if (target.getLeft() == null && target.getRight() == null) {
                //判断target是它父节点的左子节点还是右子节点
                if (parent.getLeft() != null && parent.getLeft().getValue() == value) {
                    parent.setLeft(null);
                } else if (parent.getRight() != null && parent.getRight().getValue() == value) {
                    parent.setRight(null);
                }
            }
            //2、要删除的节点有一个子树
            if ((target.getLeft() != null && target.getRight() == null) ||
                    (target.getLeft() == null && target.getRight() != null)) {
                //判断target的子节点是否有子节点
                if (target.getLeft() != null) {
                    //判断target是parent的左子节点还是右子节点
                    if (parent.getLeft().getValue() == value) {
                        parent.setLeft(target.getLeft());
                    } else {
                        parent.setRight(target.getLeft());
                    }
                } else {
                    //判断target是parent的左子节点还是右子节点
                    if (parent.getLeft().getValue() == value) {
                        parent.setLeft(target.getRight());
                    } else {
                        parent.setRight(target.getRight());
                    }
                }
            }
            //3、要删除的节点有两个子树
            if (target.getLeft() != null && target.getRight() != null) {
                //这个是用的3实现的
                int minValue = treeMin(target.getRight());
                target.setValue(minValue);
            }
        }
    }

​ 下面的这些操作与我之前文章当中 树-java语言描述 之中是一样的。

2.3、前序遍历
2.4、中序遍历
2.5、后序遍历
2.6、前序查找
2.7、中序查找
2.8、后序查找
3、完整的源码
public class BinarySortTreeDemo {
    public static void main(String[] args) {
        int[] array = {7, 3, 10, 1, 5, 9, 12, 2};
        BinarySortTree binarySortTree = new BinarySortTree();
        for (int i = 0; i < array.length; i++) {
            binarySortTree.add(new Nodes(array[i]));
        }
        //遍历
        System.out.print("前序遍历：");
        binarySortTree.preOrder();
        System.out.println();
        System.out.print("中序遍历：");
        binarySortTree.middleOrder();
        System.out.println();
        System.out.print("后序遍历：");
        binarySortTree.afterOrder();
        System.out.println();
        System.out.println("-------------------");

        //删除
//        System.out.print("删除前：");
//        binarySortTree.middleOrder();
//        System.out.println();
//        System.out.print("删除后：");
//        binarySortTree.deleteNode(2);
//        binarySortTree.middleOrder();
//        System.out.println();
//        System.out.println("-------------------");

//        System.out.print("删除前：");
//        binarySortTree.middleOrder();
//        System.out.println();
//        System.out.print("删除后：");
//        binarySortTree.deleteNode(1);
//        binarySortTree.middleOrder();
//        System.out.println();
//        System.out.println("-------------------");

//        System.out.print("删除前：");
//        binarySortTree.middleOrder();
//        System.out.println();
//        System.out.print("删除后：");
//        binarySortTree.deleteNode(10);
//        binarySortTree.middleOrder();
//        System.out.println();
//        System.out.println("-------------------");
    }
}

//二叉排序树
class BinarySortTree {
    private Nodes root;

    //添加节点的办法
    public void add(Nodes nodes) {
        if (root == null) {
            root = nodes;
        } else {
            root.add(nodes);
        }
    }

    //前序遍历
    public void preOrder() {
        if (root != null) {
            root.preOrder();
        } else {
            System.out.println("二叉排序树为空，不能遍历！");
        }
    }

    //中序遍历
    public void middleOrder() {
        if (root != null) {
            root.middleOrder();
        } else {
            System.out.println("二叉排序树为空，不能遍历！");
        }
    }

    //后序遍历
    public void afterOrder() {
        if (root != null) {
            root.afterOrder();
        } else {
            System.out.println("二叉排序树为空，不能遍历！");
        }
    }

    //查找要被删除的节点
    public Nodes search(int value) {
        if (root == null) {
            return null;
        } else {
            return root.search(value);
        }
    }

    //查找要被删除节点的父节点
    public Nodes searchParent(int value) {
        if (root == null) {
            return null;
        } else {
            return root.searchParent(value);
        }
    }

    /**
     * @param nodes 传入的节点当作该二叉树的根节点
     * @return 返回以 nodes为根节点的二叉排序树的最小节点的值
     */
    public int treeMin(Nodes nodes) {
        Nodes target = nodes;
        //循环查找左子节点
        while (target.getLeft() != null) {
            target = target.getLeft();
        }
        //删除这个值最小的节点
        deleteNode(target.getValue());
        return target.getValue();
    }

    //删除节点
    public void deleteNode(int value) {
        if (root == null) {
            return;
        } else {
            //1、先找到需要删除的节点
            Nodes target = search(value);

            //如果没找到需要删除的节点
            if (target == null) {
                return;
            }
            //只有一个节点
            if (root.getLeft() == null && root.getRight() == null) {
                root = null;
                return;
            }

            //2、找到需要删除节点的父节点
            Nodes parent = searchParent(value);

            //判断要删除的节点位于该二叉树的哪个位置
            //1、要删除的节点是叶子节点
            if (target.getLeft() == null && target.getRight() == null) {
                //判断target是它父节点的左子节点还是右子节点
                if (parent.getLeft() != null && parent.getLeft().getValue() == value) {
                    parent.setLeft(null);
                } else if (parent.getRight() != null && parent.getRight().getValue() == value) {
                    parent.setRight(null);
                }
            }
            //2、要删除的节点有一个子树
            if ((target.getLeft() != null && target.getRight() == null) ||
                    (target.getLeft() == null && target.getRight() != null)) {
                //判断target的子节点是否有子节点
                if (target.getLeft() != null) {
                    //判断target是parent的左子节点还是右子节点
                    if (parent.getLeft().getValue() == value) {
                        parent.setLeft(target.getLeft());
                    } else {
                        parent.setRight(target.getLeft());
                    }
                } else {
                    //判断target是parent的左子节点还是右子节点
                    if (parent.getLeft().getValue() == value) {
                        parent.setLeft(target.getRight());
                    } else {
                        parent.setRight(target.getRight());
                    }
                }
            }
            //3、要删除的节点有两个子树
            if (target.getLeft() != null && target.getRight() != null) {
                //这个是用的3实现的
                int minValue = treeMin(target.getRight());
                target.setValue(minValue);
            }
        }
    }
}

//节点类
class Nodes {
    private int value;
    private Nodes left;
    private Nodes right;

    public Nodes(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    public Nodes getLeft() {
        return left;
    }

    public void setLeft(Nodes left) {
        this.left = left;
    }

    public Nodes getRight() {
        return right;
    }

    public void setRight(Nodes right) {
        this.right = right;
    }

    /**
     * 添加节点
     *
     * @param node 需要添加的值
     */
    public void add(Nodes node) {
        if (node == null) {
            return;
        }
        //判断传入的节点与当前节点的关系来决定如何插入
        if (node.getValue() < this.value) {
            //如果当前节点的左节点为空
            if (this.getLeft() == null) {
                this.setLeft(node);
            } else {
                this.getLeft().add(node);
            }
        } else {
            //如果当前节点的右节点为空
            if (this.getRight() == null) {
                this.setRight(node);
            } else {
                this.getRight().add(node);
            }
        }
    }

    //前序遍历
    public void preOrder() {
        System.out.print(this.getValue() + "->");
        if (this.left != null) {
            this.left.preOrder();
        }
        if (this.right != null) {
            this.right.preOrder();
        }
    }

    /**
     * 查找要删除的节点
     *
     * @param value 要查找的值
     * @return 返回被找到的值
     */
    public Nodes search(int value) {
        if (this.getValue() == value) {
            return this;
        } else if (this.getValue() > value) {     //向左子节点查找
            if (this.getLeft() == null) {
                return null;
            } else {
                //向左子树递归查找
                return this.getLeft().search(value);
            }
        } else {                                 //向右子节点查找
            if (this.getRight() == null) {
                return null;
            } else {
                //向右子树递归查找
                return this.getRight().search(value);
            }
        }
    }

    /**
     * 查找要删除节点的父节点
     *
     * @param value 要查找的节点的值
     * @return 返回被查找到的节点的父节点
     */
    public Nodes searchParent(int value) {
        //当前节点的子节点就是要删除的节点
        if ((this.getLeft() != null && this.getLeft().getValue() == value) ||
                (this.getRight() != null && this.getRight().getValue() == value)) {
            return this;
        } else {
            //当前节点的值大于value，且当前节点的左节点不为空
            if (this.getValue() > value && this.getLeft() != null) {
                return this.getLeft().searchParent(value);
                //当前节点的值小于value，且当前节点的右节点不为空
            } else if (this.getValue() < value && this.getRight() != null) {
                return this.getRight().searchParent(value);
                //没有找到符合条件的
            } else {
                return null;
            }
        }
    }
}
完成二叉排序树的创建、查找、插入和删除操作。
weixin_57168038的博客
06-19 827
publicclassBinarySortTree { /** * 根结点 */ privateTreeNode rootNode; /** * 获取rootNode * @return */ publicTreeNode getRootNode() { returnthis.rootNode; } /** * 创...
完全二叉树的判断java,判断二叉树是否为完全二叉树的实例
weixin_29166013的博客
03-10 324
完全二叉树特点完全二叉树是指除了最后一层之外，其他每一层的结点数都是满的。最后一层如果也满了，是一颗满二叉树，也是完全二叉树。最后一层如果不满，缺少的结点也全部的集中在左边，那也是一颗完全二叉树。判断一棵二叉树是否为完全二叉树import java.util.*;class TreeNode {int val = 0;TreeNode left = null;TreeNode right = nu...
判断一颗二叉树是否为二叉排序树？
weixin_46899589的博客
11-15 1951
算法思想:对一颗二叉排序树来说，其中序遍历序列为一个递增有序序列，因此，对给定的二叉树进行中序遍历，如果始终能保持前一个值比后一个值小，则说明该二叉树是一棵二叉排序树 typedef struct node { DataType data; struct node *lchild; struct node *rchild; }BTNode; KeyType pre=-32767; //pre为全局变量，保存当前节点中序前驱的值，初值为-∞ int judgeBST(BTNode *T)
Java---判断一棵树是否为二叉查找树BST
shall潇の菜园
03-04 553
Java—判断一棵树是否为二叉查找树BST 思路：对于一棵二叉树，最简单的方法就是中序遍历，看是不是一个递增数列，如果是，则是一棵二叉搜索树，如果不是，则不是二叉搜索树。在这里用一个lastVisit去记录上一次搜索的节点。这个过程就是先找到最左下角的节点，更新lastVisit为这个节点的值，然后按照中序遍历依次更新即可。 代码实现： /** * @Author shall潇 * @Date 2021/3/4 * @Description */ public class BinaryTree {
判断一棵树是否为二叉排序树
weixin_30498921的博客
05-13 192
今天看到了一段判断是否为二叉排序树的代码，感觉有点问题，在网上一搜还真有不少这么做的 原本的思路大概是这样的吧，判断根节点值是否比左子节点的值大且比右子节点的值小，若成立，递归判断左子右子。不成立返回false，代码就不贴了。 想了一下，如果下面这样的树是不是也判定为二叉排序树，但是根据定义，这不是一个二叉排序树。。。 下面来看定义，百度就有。。 二叉排序树（Binary Sort T...
algorithm-java:常用算法-java语言描述
05-21
algorithm-java ...二叉查找树 cn.fh.apply 表达式求值 cn.fh.util 统计代码执行耗时的计时器(Stopwatch) 从Stdin中读入测试数据(ReadData) largeW.txt中包含100万个整数。smallW.txt包含4万个整数。
数据结构解析：二叉排序树在Java中的应用
标签中提到的"Java"意味着我们可能会用Java语言实现二叉排序树的相关操作。在Java中，二叉树节点通常用类来表示，包括节点值、左子节点和右子节点等属性，以及插入、删除和查找等方法。例如： ```java class Node {...
java二叉查找树的实现代码
08-29
标题中提到了java二叉查找树的实现代码，而描述则详细介绍了java二叉查找树的实现代码，具有一定的参考价值。从这里我们可以看到，二叉查找树是一种搜索树，它能够快速地搜索、插入、删除树中的节点。 二、标签 ...
数据结构与算法分析-Java语言描述(第3版)源码.rar
03-18
《数据结构与算法分析-Java语言描述(第3版)源码》是计算机科学领域的一本经典教材，主要关注如何用Java语言实现各种数据结构和算法。这本书的第三版不仅涵盖了基本的数据结构如数组、链表、栈、队列、树、图，还深入...
java二叉排序树_二叉排序树Java实现(Binary Sort Tree)
weixin_33664286的博客
02-16 261
二叉排序树又称二叉查找树，它是一种对排序和查找都很有用的特殊二叉树。二叉树的定义：二叉树或者是一颗空树，或者是具有下列性质的二叉树：1.若它的左子树不为空，则左子树上所有结点的值均小于它的根结点的值；2.若它的右子树不为空，则右子树上所有结点的值均大于它的根结点的值；3.它的左右子树也分别为二叉排序树。简单的说就是(左 二叉排序树的创建：从空的二叉排序树开始，每输入一个结点，经过查找操作，将新结点...
搜索二叉树的判断（java）
weixin_51713937的博客
01-24 902
1、特点 1、搜索树——左结点的value都是小于头结点的，右结点的value都是大于头结点的。 2、搜索树——中序遍历是升序排序的。 2、方法主体 1、中序遍历时——中间是打印，如今可以换成判定条件 2、判定条件——因为中序遍历时是升序的，所以，当前节点的value值是大于上一个节点的value值的——所以只用判断这两个节点值即可。 3、比较方法——这时我们可以定义一个全局变量保存上一个节点值——因为递归函数没每次都会从头出发——所以应该定义一个在方法外的变量来保存上一个节点值。 4、判断结果——当
笔试面试算法经典--判断二叉树是否是平衡二叉树（Java）
有图有真相
04-11 4073
平衡二叉树（Balanced Binary Tree）又被称为AVL树，且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。如下面的三棵树：只有中间才是平衡二叉树。解法： 思路1：从根节点开始，求出根的左右子树的高度，如果根的左右子树的高度差大于1，返回FALSE，否则递归的判断根的左子树和右子树是否满足条件。class TreeNode{
判断二叉树是否为二叉排序树
qq_51691366的博客
10-21 4603
该算法的实现是借助中序遍历来实现的，因为我们知道符合要求的二叉排序树的特点是父节点的值大于左子树的值但是小于右子树的值，所以借助在每一棵子树都有这样的特点，可以设计实现对二叉排序树的判断！当然该算法也可以直接使用先序遍历来实现！每当访问一个结点的时候就判断当前结点和孩子结点的大小关系！如果不满足二叉排序树的特点可以直接返回结果！分别在左右孩子同时存和一个存在一个不存在的情况下来实现算法！
判断一棵二叉树是否为二叉排序树
热门推荐
C.
10-16 3万+
二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于或等于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值； （3）左、右子树也分别为二叉排序树；#include<stdio.h> #i
判断二叉树是否为二叉排序树的算法_如何判断一颗二叉树是否是二叉搜索树？...
weixin_39863161的博客
12-14 679
鉴于二叉搜索树做中序遍历之后得到的序列是严格单调递增的，所以最简单的方法当然是先对二叉树做中序遍历，然后对得到的序列进行有序性判断。这个方法唯一的缺点是效率不好：它需要遍历每个节点的值两次（至少一次），并且需要 的辅助空间 。对这中序遍历的方法稍作修改，目标是当遇到某个节点违反二叉搜索树的性质时就返回False，并且消除高达的辅助空间的利用。一个简单的办法是在进行中序遍历时，只保留一个最大值（当前...
判断一棵树是否为二叉排序树的两种方法
weixin_33726943的博客
10-15 812
一、使用先根遍历，判断大小关系是否正确：t->lchild->value<t->value<t->rchild->value bool Judge(PBinTree pbt){ PBinTreeNode pLeft, pRight; bool bLeft = false, bRight=false, bRo...
判断一棵二叉树是否是二叉排序树
The_star_is_at的博客
06-14 2333
分析：是否是二叉排序树，即看树的中序遍历是否为递增的即可 typedef struct node { ElemType data; struct node *lchild,*rchild; }BTree; void solve(BTree T,int flag) { if(T && flag) { solve(T->lchild,flag);//中序遍历左子树 if(pre ==
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值