排序二叉树(BST)

最新推荐文章于 2025-05-13 14:30:16 发布
原创 最新推荐文章于 2025-05-13 14:30:16 发布 · 1k 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

文章目录

描述

英文全称：Binary Sort Tree，它满足以下3个特点：
1.一个节点的左节点的值，一定小于它本身节点的值
2.一个节点的右节点的值，一定大于它本身节点的值
3.一个节点的左右子树，都属于排序二叉树

相关操作

1、树节点构造

class Node {
    int data;
    Node left;
    Node right;

    public Node() {
    }

    public Node(int data) {
        this.data = data;
    }
}

2、遍历树（中序遍历）

	/**
     * 中序遍历
     *
     * @param node
     */
    private void travel(Node node) {
        if (node == null) {
            return;
        }
        travel(node.left);
        System.out.print(node.data + " ");
        travel(node.right);
    }

3、添加节点

	/**
     * 添加节点
     *
     * @param data
     */
    private void add(int data) {
        Node newNode = new Node(data);
        if (root == null) {
            root = newNode;
            return;
        }

        Node current = root;
        while (true) {
            if (current.data > data) {
                if (current.left == null) {
                    current.left = newNode;
                    return;
                }
                current = current.left;
            } else {
                if (current.right == null) {
                    current.right = newNode;
                    return;
                }
                current = current.right;
            }
        }
    }

4、寻找某个节点

	/**
     * 寻找某个节点
     *
     * @param value
     * @return
     */
    private Node findNode(int value) {
        Node current = root;
        while (true) {
            if (current == null) {
                return null;
            }
            if (current.data == value) {
                return current;
            }
            if (current.data > value) {
                current = current.left;
            } else {
                current = current.right;
            }
        }
    }

5、删除操作

除了空树和待删除节点不存在以外，删除操作有以下3中情况：

  • 待删除节点是叶子结点

直接删除

  • 待删除节点拥有左子树或者右子树

直接删除，并向上拼接左子树或者右子树

  • 待删除节点既有左子树又有右子树

找到中序排序下的前驱或者后驱节点（即是中序排序后，前后节点；这里寻找后节点，即是后驱节点），用它代替待删除节点

	/**
     * 删除某个节点(三种情况)
     *
     * @param value
     * @return
     */
    private Node del(int value) {
        //空树
        if (root == null) {
            return null;
        }
        Node target = findNode(value);
        Node targetParent = findNodeParent(value);
        if (target == null) {
            return null;
        } else {
            //找到了待删除节点
            //情况1:待删除节点没有左右子树 -> 直接删除
            if (target.left == null && target.right == null) {
                if (targetParent == null) {
                    //表示没有子树和父节点，整棵树只有待删除节点一个节点，直接置空
                    root = null;
                    return target;
                } else {
                    //有父节点，但有可能是该父节点的左或右子节点
                    if (targetParent.left == null) {
                        targetParent.right = null;
                        return target;
                    } else {
                        targetParent.left = null;
                        return target;
                    }
                }

            } else if (target.left == null || target.right == null) {
                //情况2:待删除节点有左子树或者右子树 -> 删除待删除节点，将待删除节点的左子树或右子树嫁接到它的父节点
                if (target.left == null) {
                    if (targetParent == null) {
                        root = target.right;
                        return target;
                    }
                    if (targetParent.left != null && target.left.data == value) {
                        targetParent.left = target.right;
                        return target;
                    } else {
                        targetParent.right = target.right;
                        return target;
                    }
                } else {
                    if (targetParent == null) {
                        root = target.left;
                        return target;
                    }
                    if (targetParent.left != null && target.left.data == value) {
                        targetParent.left = target.left;
                        return target;
                    } else {
                        targetParent.right = target.left;
                        return target;
                    }
                }
            } else {
                //情况3:待删除节点既有左子树又有右子树 -> 找到中序排序下的前驱或者后驱节点（即是中序排序后，前后节点；这里寻找后节点，即是后驱节点），用它代替待删除节点
                Node finalLeft = findFinalLeft(target);
                int data = finalLeft.data;
                del(data);
                target.data = data;
            }
        }
        return null;
    }

完整代码

package com.cxf.datastructures.binarytree;

/**
 * 排序二叉树
 */
public class BinarySortTree {

    public static void main(String[] args) {
        BinarySortTree binarySortTree = new BinarySortTree();
        binarySortTree.add(3);
        binarySortTree.add(1);
        binarySortTree.add(6);
        binarySortTree.add(5);
        binarySortTree.add(2);
        binarySortTree.add(9);
        binarySortTree.add(7);

        System.out.println("删除前： ");
        binarySortTree.travel(binarySortTree.root);

        binarySortTree.del(6);
        System.out.println();

        System.out.println("删除后： ");
        binarySortTree.travel(binarySortTree.root);
    }

    private Node root;

    /**
     * 中序遍历
     *
     * @param node
     */
    private void travel(Node node) {
        if (node == null) {
            return;
        }
        travel(node.left);
        System.out.print(node.data + " ");
        travel(node.right);
    }

    /**
     * 添加节点
     *
     * @param data
     */
    private void add(int data) {
        Node newNode = new Node(data);
        if (root == null) {
            root = newNode;
            return;
        }

        Node current = root;
        while (true) {
            if (current.data > data) {
                if (current.left == null) {
                    current.left = newNode;
                    return;
                }
                current = current.left;
            } else {
                if (current.right == null) {
                    current.right = newNode;
                    return;
                }
                current = current.right;
            }
        }
    }

    /**
     * 寻找某个节点
     *
     * @param value
     * @return
     */
    private Node findNode(int value) {
        Node current = root;
        while (true) {
            if (current == null) {
                return null;
            }
            if (current.data == value) {
                return current;
            }
            if (current.data > value) {
                current = current.left;
            } else {
                current = current.right;
            }
        }
    }

    /**
     * 寻找某个节点的父节点
     *
     * @param value
     * @return
     */
    private Node findNodeParent(int value) {
        if (root == null) {
            return null;
        }
        if (root.data == value) {
            return null;
        }
        Node current = root;
        while (true) {
            if (current == null) {
                return null;
            }
            if (current.data > value) {
                if (current.left == null) {
                    return null;
                }
                if (current.left.data == value) {
                    return current;
                }
                current = current.left;
            } else {
                if (current.right == null) {
                    return null;
                }
                if (current.right.data == value) {
                    return current;
                }
                current = current.right;
            }
        }
    }

    /**
     * 寻找中序遍历下node节点的后驱节点
     * 找到以node为根的树的左边的左边的左边的...的那个节点
     *
     * @param node
     * @return
     */
    private Node findFinalLeft(Node node) {
        while (node.left != null) {
            node = node.left;
        }
        return node;
    }

    /**
     * 删除某个节点(三种情况)
     *
     * @param value
     * @return
     */
    private Node del(int value) {
        //空树
        if (root == null) {
            return null;
        }
        Node target = findNode(value);
        Node targetParent = findNodeParent(value);
        if (target == null) {
            return null;
        } else {
            //找到了待删除节点
            //情况1:待删除节点没有左右子树 -> 直接删除
            if (target.left == null && target.right == null) {
                if (targetParent == null) {
                    //表示没有子树和父节点，整棵树只有待删除节点一个节点，直接置空
                    root = null;
                    return target;
                } else {
                    //有父节点，但有可能是该父节点的左或右子节点
                    if (targetParent.left == null) {
                        targetParent.right = null;
                        return target;
                    } else {
                        targetParent.left = null;
                        return target;
                    }
                }

            } else if (target.left == null || target.right == null) {
                //情况2:待删除节点有左子树或者右子树 -> 删除待删除节点，将待删除节点的左子树或右子树嫁接到它的父节点
                if (target.left == null) {
                    if (targetParent == null) {
                        root = target.right;
                        return target;
                    }
                    if (targetParent.left != null && target.left.data == value) {
                        targetParent.left = target.right;
                        return target;
                    } else {
                        targetParent.right = target.right;
                        return target;
                    }
                } else {
                    if (targetParent == null) {
                        root = target.left;
                        return target;
                    }
                    if (targetParent.left != null && target.left.data == value) {
                        targetParent.left = target.left;
                        return target;
                    } else {
                        targetParent.right = target.left;
                        return target;
                    }
                }
            } else {
                //情况3:待删除节点既有左子树又有右子树 -> 找到中序排序下的前驱或者后驱节点（即是中序排序后，前后节点；这里寻找后节点，即是后驱节点），用它代替待删除节点
                Node finalLeft = findFinalLeft(target);
                int data = finalLeft.data;
                del(data);
                target.data = data;
            }
        }
        return null;
    }

}

class Node {
    int data;
    Node left;
    Node right;

    public Node() {
    }

    public Node(int data) {
        this.data = data;
    }
}
排序二叉树BST转双向链表
qq_39350434的博客
08-27 430
基于c实现排序二叉树转为双向链表，无需重新再创建一个双向链表结构体，直接对树的指针操作。 代码： #include <stdlib.h> #include <stdio.h> typedef struct tree { int nValue; struct tree *pLeft; struct tree *pRight; }BST; void AddNode(BST **pTree, int num) { BST *pTemp = (BST*)malloc(sizeof
数据结构-二叉排序树（图文详细版）
淡沫初夏zz的博客
01-17 6万+
二叉排序树
数据结构-----二叉排序树
m0_73633088的博客
10-01 3万+
今天我们继续学习新的知识点----排序二叉树，在此之前我们学习了相关的排序算法，给你一个数组，然后对这个数组进行排序。那么同样的我们也可以去构建一个二叉排序树，在创建树的过程中进行排序，也能实现排序的效果，下面就一起来看看吧！二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。是数据结构中的一类。在一般情况下，查询效率比链表结构要高。给定一个二叉树，如果满足以下条件，那就是二叉排序树。
二叉排序树详解
云杉木屋
04-01 2万+
摘要：本篇笔记专门介绍二叉排序树，重点讲解了二叉排序树的特性，以及二叉排序树各方面的基本实现。
二叉排序树（二叉查找树、二叉搜索树）（图解+完整代码）
热门推荐
weixin_54186646的博客
04-25 10万+
图解二叉排序树（二叉查找树、二叉搜索树）的插入操作、查找操作、删除操作以及完整的代码实现
详解数据结构——二叉排序树
莫浅子的博客
10-29 1万+
二叉排序树，又称二叉查找树（BST，Binary Search Tree)一棵二叉树或者是空二叉树，或者是具有如下性质的二叉树: 左子树上所有结点的关键字均小于根结点的关键字; 右子树上所有结点的关键字均大于根结点的关键字。左子树和右子树又各是一棵二叉排序树 左子树结点值
排序二叉树（BST）
qq_42211587的博客
06-09 678
/* 排序二叉树 BST 时间复杂度为 LOG n 2 */ #include <iostream> #include <stack> using namespace std; typedef struct node { int value; struct node *left,*right; }...
排序二叉树BST的基本操作(2)前驱，后继，删除
BUILD
09-29 6008
前文中写了基本操作中的插入，查找，最大节点，最小节点。本文主要写如何进行删除。 删除的最重要的原则是，删除后依然要维护BST的性质，也就是说，中序遍历后为升序。 删除的思路有三个。  思路一 先理解前驱和后继的含义。 节点key的前驱，就是中序遍历时，比key小的所有节点中最大的那个节点。 节点key的后继，就是中序遍历时，比key小的所有节点中最大的那个节点。 容易看出，节点
二叉排序树（BST），平衡二叉树（AVL）
最新发布
2303_79383388的博客
05-13 1224
二叉排序树和平衡二叉树的增删查操作。
java数据结构与算法（二叉排序树【BST】，平衡二叉树【AVL】）
qq_48627750的博客
11-18 899
Java数据结构与算法 二叉排序树（BST） 平衡二叉树（AVL）
二叉排序树
weixin_30828379的博客
04-17 446
二叉排序树又称“二叉查找树”、“二叉搜索树”（简称\(BST\)）。二叉排序树：或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。  从BST性质可推出：按中序遍历该树所得到的中序序列是一个递增的有序序列 构造\(BST:\...
数据结构-二叉排序树（BST树）
理科男同学
11-15 1万+
1，二叉排序树介绍 二叉排序树（Binary Sort Tree）或者是一颗空树；或者是具有如下性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树又分别为二叉排序树。 显然二叉排序树的定义是一个递归形式的定义，所以后面景禹要讲的插入、查找和删除都是基于递归的形式。特别说明：如果有相同的值，可以将该节点放在左子节点或右子节点 1.1，二叉排序树的构建 假设我们有初始的无序...
排序二叉树
zhj12399的博客
11-22 1040
排序二叉树题目信息输入输出测试样例解答 题目信息 排序二叉树是指左子树的所有节点的值均小于它根节点的值，右子树的所有节点的值均大于它根节点的值。 输入 输入有一行，表示若干个要排序的数，输入0时停止 输出 二叉树的凹入表示 和二叉树的中序遍历序列 测试样例 42 168 35 101 270 125 79 259 263 165 6 246 182 62 192 296 243 28 37 0 6 28 35 37 42
【数据结构】建立二叉排序树和二叉排序树的插入、查找、删除操作
m0_72895175的博客
08-20 791
二叉排序树（Binary Sort Tree），又称为二叉查找树，是一种特殊的二叉树。
【数据结构】17-二叉排序树（BST）
qqqking的博客
04-27 439
一、介绍 二、代码 package cn.qqqking.binarysorttree; import java.util.Arrays; /** * @author AnQi * @date 2020/4/26 10 03:13 * @description */ public class BinarySortTreeDemo { public static void main...
数据结构（34）二叉排序树
李白
06-20 1万+
目录 1、二叉排序树（BST,Binary Sort Tree）定义 2、二叉排序树的查找 3、二叉排序树的插入 4、二叉排序树的构造 6、二叉排序树的查找效率分析 7、二叉排序树与二分排序对比 1、二叉排序树（BST,Binary Sort Tree）定义 二叉排序树（也称为二叉查找树）或者是一棵空树，或者是具有以下特性的二叉树： 1）若左子树非空，则左子树上所有结点的值均小于根节点的值。 2）若右子树非空，则右子树上所有结点的值均大于根节点的值。 3）左、右子树也分别是一棵二叉排序
数据结构 | 顺序二叉树
鷾
07-01 1211
顺序二叉树的基本操作以及各种遍历，包括先序遍历、层次遍历
数据结构之排序二叉树
qq_24428851的博客
01-11 752
如果大于当前节点，则到右子树中寻找，如果右子树为空则当前节点为要找的父节点，新节点插入到当前节点的右子树即可。2）如果该节点无右子节点，则后继节点为父节点或者某个祖先节点，从当前节点往上找，如果它是父节点的右孩子，则继续找父节点，直到它不是右孩子或父节点为空，第一个非右孩子节点的父节点就是后继节点，如果找不到这样的祖先节点，则后继为空，遍历结束。二叉树是一种从上往下的树状结构的数据结构，从根节点开始每个节点最多有两个子节点，左边的为左子节点，右边的为右子节点。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值