JAVA中二叉搜索树的实现

最新推荐文章于 2024-08-07 17:24:39 发布
最新推荐文章于 2024-08-07 17:24:39 发布
阅读量104 收藏
点赞数
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33126189/article/details/106056034
版权

基本性质：首先是一棵二叉树，其次每个节点的值大于其左子树上节点的值，小于其右子树上节点的值。

结构：

public class myBST {

    Node root = null;

    class Node {
        int value;
        Node left_child = null;
        Node right_child = null;

        Node(int value) {
            this.value = value;
        }
    }
}

节点的插入：

public void Insert(int value) {
        if (root == null) {
            root = new Node(value);
            return;
        }

        Node cur = root;
        while (cur != null) {
            if (value < cur.value) {
                if (cur.left_child != null) {
                    cur = cur.left_child;
                } else {
                    cur.left_child = new Node(value);
                    return;
                }
            } else if (value > cur.value) {
                if (cur.right_child != null) {
                    cur = cur.right_child;
                } else {
                    cur.right_child = new Node(value);
                    return;
                }
            }
        }
    }

节点的寻找：

public boolean Find(int value) {
        Node cur = root;
        while (cur != null) {
            if (cur.value == value) {
                return true;
            } else if (cur.value < value) {
                cur = cur.right_child;
            } else {
                cur = cur.left_child;
            }
        }
        return false;
    }

节点的删除，分为三种情况：

public boolean Delete(int value) {
        Node parent = root;
        Node cur = root;
        while (cur != null) {
            if (value == cur.value) {
                break;
            } else if (value < cur.value) {
                parent = cur;
                cur = cur.left_child;
            } else {
                parent = cur;
                cur = cur.right_child;
            }
        }

        if (cur == null) {
            //没有找到
            return false;
        }

        if (cur.left_child == null && cur.right_child == null) {
            if (cur == parent) {
                //是根节点
                root = null;
                return true;
            } else {
                //是叶子节点
                cur = null;
                return true;
            }
        } else if (cur.left_child != null && cur.right_child == null) {
            //待删除的节点只有左节点
            if (cur == parent) {
                root = cur.left_child;
                return true;
            } else {
                if (cur == parent.left_child) {
                    parent.left_child = cur.left_child;
                    return true;
                } else {
                    parent.right_child = cur.left_child;
                    return true;
                }
            }
        } else if (cur.left_child == null && cur.right_child != null) {
            //待删除的节点只有右节点
            if (cur == parent) {
                root = cur.right_child;
                return true;
            } else {
                if (cur == parent.left_child) {
                    parent.left_child = cur.right_child;
                    return true;
                } else {
                    parent.right_child = cur.right_child;
                    return true;
                }
            }
        } else {
            //待删除的节点左节点和右节点都存在
            //将左子树链接到右子树最左的节点下
            Node temp = cur.right_child;
            while (temp.left_child != null) {
                temp = temp.left_child;
            }
            temp.left_child = cur.left_child;

            if (parent != cur) {
                if (parent.left_child == cur) {
                    parent.left_child = cur.right_child;
                } else {
                    parent.right_child = cur.right_child;
                }
            } else {
                root = cur.right_child;
            }
            return true;
        }
    }

三种遍历：

    //根、左、右
    public void PreOrder(Node node) {
        if (node != null) {
            System.out.print(node.value + " ");
            PreOrder(node.left_child);
            PreOrder(node.right_child);
        }
    }

    public void PreOrder() {
        PreOrder(root);
    }

    //左、根、右
    public void inOrder(Node node) {
        if (node != null) {
            inOrder(node.left_child);
            System.out.print(node.value + " ");
            inOrder(node.right_child);
        }
    }

    public void inOrder() {
        inOrder(root);
    }

    public void posOrder(Node node) {
        if (node != null) {
            posOrder(node.left_child);
            posOrder(node.right_child);
            System.out.print(node.value + " ");
        }
    }

    public void posOrder() {
        posOrder(root);
    }

完成的程序：

package myBST;

public class myBST {

    Node root = null;

    class Node {
        int value;
        Node left_child = null;
        Node right_child = null;

        Node(int value) {
            this.value = value;
        }
    }

    public void Insert(int value) {
        if (root == null) {
            root = new Node(value);
            return;
        }

        Node cur = root;
        while (cur != null) {
            if (value < cur.value) {
                if (cur.left_child != null) {
                    cur = cur.left_child;
                } else {
                    cur.left_child = new Node(value);
                    return;
                }
            } else if (value > cur.value) {
                if (cur.right_child != null) {
                    cur = cur.right_child;
                } else {
                    cur.right_child = new Node(value);
                    return;
                }
            }
        }
    }

    public boolean Find(int value) {
        Node cur = root;
        while (cur != null) {
            if (cur.value == value) {
                return true;
            } else if (cur.value < value) {
                cur = cur.right_child;
            } else {
                cur = cur.left_child;
            }
        }
        return false;
    }

    public boolean Delete(int value) {
        Node parent = root;
        Node cur = root;
        while (cur != null) {
            if (value == cur.value) {
                break;
            } else if (value < cur.value) {
                parent = cur;
                cur = cur.left_child;
            } else {
                parent = cur;
                cur = cur.right_child;
            }
        }

        if (cur == null) {
            //没有找到
            return false;
        }

        if (cur.left_child == null && cur.right_child == null) {
            if (cur == parent) {
                //是根节点
                root = null;
                return true;
            } else {
                //是叶子节点
                cur = null;
                return true;
            }
        } else if (cur.left_child != null && cur.right_child == null) {
            //待删除的节点只有左节点
            if (cur == parent) {
                root = cur.left_child;
                return true;
            } else {
                if (cur == parent.left_child) {
                    parent.left_child = cur.left_child;
                    return true;
                } else {
                    parent.right_child = cur.left_child;
                    return true;
                }
            }
        } else if (cur.left_child == null && cur.right_child != null) {
            //待删除的节点只有右节点
            if (cur == parent) {
                root = cur.right_child;
                return true;
            } else {
                if (cur == parent.left_child) {
                    parent.left_child = cur.right_child;
                    return true;
                } else {
                    parent.right_child = cur.right_child;
                    return true;
                }
            }
        } else {
            //待删除的节点左节点和右节点都存在
            //将左子树链接到右子树最左的节点下
            Node temp = cur.right_child;
            while (temp.left_child != null) {
                temp = temp.left_child;
            }
            temp.left_child = cur.left_child;

            if (parent != cur) {
                if (parent.left_child == cur) {
                    parent.left_child = cur.right_child;
                } else {
                    parent.right_child = cur.right_child;
                }
            } else {
                root = cur.right_child;
            }
            return true;
        }
    }

    //根、左、右
    public void PreOrder(Node node) {
        if (node != null) {
            System.out.print(node.value + " ");
            PreOrder(node.left_child);
            PreOrder(node.right_child);
        }
    }

    public void PreOrder() {
        PreOrder(root);
    }

    //左、根、右
    public void inOrder(Node node) {
        if (node != null) {
            inOrder(node.left_child);
            System.out.print(node.value + " ");
            inOrder(node.right_child);
        }
    }

    public void inOrder() {
        inOrder(root);
    }

    public void posOrder(Node node) {
        if (node != null) {
            posOrder(node.left_child);
            posOrder(node.right_child);
            System.out.print(node.value + " ");
        }
    }

    public void posOrder() {
        posOrder(root);
    }

    public static void main(String[] args) {
        int[] nums = {50, 25, 65, 15, 35, 55, 70, 10, 20, 30, 36};
        myBST bst = new myBST();
        for (int i = 0; i < nums.length; i++) {
            bst.Insert(nums[i]);
        }
        bst.PreOrder();
        System.out.println();
        bst.Delete(50);
        bst.PreOrder();
        System.out.println();
//        System.out.println(bst.Find(33));
    }
}

 

孤鹏万里征
关注
专栏目录
BinarySearchTree:Java中二叉搜索树的实现
06-11
在Java中，我们通常使用类来实现二叉搜索树。以下是一个简单的二叉搜索树节点类的实现： ```java public class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int val) { this.val = val; }...
二叉搜索树的Java实现
机械工程跑路哥
02-24 1830
一.树的概念 树的定义：树是由n（n>=1）个有限结点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 树的特点： 1.每个结点有零个或多个子结点； 2.没有父结点的结点为根结点； 3.每一个非根结点只有一个父结点； 4.每个结点及其后代结点整体上可以看做是一棵树，称为当前结点的父结点的一个子树; 补：树的检索效率较高！ 结点的度： 一个结点含有的子树的个数称为该结点的度； —如E有两个子树，度为2； F有 KLM三个子树，度为3。根节点
二叉搜索树（BST）的java实现
c1776167012的博客
03-24 259
一.什么是二叉搜索树？ 简单来说，它是一个加了限定条件的二叉树。 条件是： 1.一个节点的左子树只能包含键值小于该节点的键值的节点。 2.一个节点的右子树只能包含键值大于该节点的键值的节点。 3.左右子树也都必须是二叉搜索树。 例如： 二.java代码的实现 1.节点的定义： class BinarySearchTreeNode{ private int data; privat...
【数据结构】二叉搜索树（Java + 链表实现）
最新发布
明志の博客
08-07 1121
Map接口是独立的实现Iterable接口的集合都是可以使用 for - Each 语句进行打印的搜索性能会非常高。
java实现，二叉搜索树(过程非常详细)
fengxiandada的博客
03-25 3412
java实现二叉搜索树
二叉搜索树的实现（JAVA）
liningxi123的博客
10-08 473
二叉搜索树java实现
Java之二叉搜索树(BST)
qq_64580912的博客
04-11 1544
（Binary Search Tree，简称因为二叉搜索树具有上述的性质，所以可以等操作。在二叉搜索树中，一个元素的，其中n是树中节点的个数。同时，在二叉搜索树中，可以按照某种顺序（如）输出树中的所有节点，因此也可以作为一种的方法。
Java中二叉树数据结构的实现示例
09-03
在计算机科学中，二叉树是一种常见的数据...理解这些概念对于处理与树相关的算法和问题至关重要，如搜索、排序、路径查找、树的平衡等。同时，递归是实现这些遍历方法的核心，对于理解和掌握递归编程技巧也有很大帮助。
java实现 二叉搜索树功能
08-27
Java 实现二叉搜索树功能 二叉搜索树是一种特殊的二叉树，它的每个节点都含有一个Comparable的键值，且所有的键值都是唯一的，节点的键值也可以是基本类型，如int、long等，也可以是自定义的对象类型，只要实现了...
Quadtree:Java中的四叉树实现
05-11
四叉树这是Quadtree的Java实现，Quadtree是一种树数据结构，可用于存储2D位置数据。用法创建新的四叉树从点（0,0）开始以400 x 400尺寸初始化世界// init.Dimension dimension = new Dimension ( 400 , 400 ); ...
使用Java实现二叉搜索树
08-03
这段代码展示了构建一个基本的二叉搜索树（Binary Search Tree, BST）的实现。二叉搜索树是一种特殊的二叉树，其中每个节点的值大于其左子树中所有节点的值，并且小于其右子树中所有节点的值。这种数据结构在查找、...
Java二叉搜索树
m0_64318128的博客
11-05 1450
二叉搜索树的概念、性质，二叉搜索树的实现
【数据结构】用Java实现二叉搜索树（二分搜索树）
qq_53869058的博客
04-05 1627
二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 一般来说二叉搜索树不存在重复的元素（JDK中的二叉搜索树也不存在重复的元素）
Java数据结构--二叉树(二叉查找树)
m0_74808313的博客
04-12 1142
二叉树是几个有限无素的集合，该集合或者为空、或者由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成，是有序树。当集合为空时，称该二叉树为空二叉树。在二叉树中，一个元素也称作一个节点。如图即为一个二叉树(可根据图片理解):注:该树并不为一棵二叉搜索树对于二叉树的遍历，可进一步分为三种:①前序遍历(根左右):对于每一棵子树，先访问该节点，然后是左子树，最后是右子树②中序遍历(左根右):对于每一棵子树，先访问左子树，然后是该节点，最后是右子树。
【DS】Java实现一个简单的二叉搜索树
weixin_56952690的博客
03-11 218
【数据结构】本文简单实现二叉搜索树各个基本操作，为以后学习AVL树和红黑树做铺垫。
Java数据结构——二叉搜索树
chenchenchencl的博客
10-19 1307
Java数据结构——二叉搜索树
搜索二叉树（Java版）
weixin_74352792的博客
05-18 359
要去实现这种方法的话我们使用到两个指针（t和tp）去完成，t指针是去找到左树的最大值（或者右树的最小值）的节点，tp指针是作为找到的节点的父亲节点，当对t指针的节点进行删除操作是，我父亲节点tp要去接盘的t节点的孩子节点（没有的话就接收null一样的）在实现前我们在观察一下，把上面的两种情况一结合是不是就相当于把我cur的左树的最大值（或者右树的最小值）赋值给cur的val值，然后删除存放左树的最大值（或者右树的最小值）的节点，就完成了我的删除操作了，我们就把这一种方法叫做”替罪羊“方法。
Java 数据结构之二叉搜索树(头歌平台，详细注释)
qwertf123的博客
11-20 663
Java 数据结构之二叉搜索树
C 语言中二叉查找树怎么实现？
03-04
C语言中二叉查找树可以通过定义一个结构体来实现。结构体包含一个指向左子树和右子树的指针，以及一个存储数据的变量。具体实现过程如下： 1. 定义结构体 ``` struct TreeNode { int data; struct TreeNode* ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值