精华内容
下载资源
问答
  • 将二叉排序树T的先序序列中的关键字依次插入到一棵空的二叉排序树中,所得到的二叉排序树T'与T是否相同?为什么?
  • 二叉排序树

    千次阅读 2015-05-14 14:26:37
    一棵空的二叉排序树中依次插入关键字序列为12,7,17,11,16,2,13,9,21,4,试编写程序创建这棵二叉排序树(要求:创建完成之后对其进行中序遍历检验其是否是递增序列以证明其正确)。 这次的博客写的...

     在一棵空的二叉排序树中依次插入关键字序列为12,7,17,11,16,2,13,9,21,4,试编写程序创建这棵二叉排序树(要求:创建完成之后对其进行中序遍历检验其是否是递增序列以证明其正确)。


    这次的博客写的就是这道题,这道题没有什么难点,关键就是对于二叉排序树的理解,这次的代码中没有写二叉排序树的删除,当然会在后面接着发出来,因为对二叉排序树来说,删除才是真的难点。对与二叉排序树,对字面意思来说,我们就能理解,就是在二叉树的基础上来排序,就是让我们创建一个有顺序的二叉树,如果我们的二叉树学的行的话,这是没有什么难点的。当然,什么都不能按照别人的方法来,每个人都要有自己的方法,针对这道题写的结构体!代码如下!

    main.cpp:

    #include <iostream>
    using namespace std;
    #include "han.h"


    int main()
    {
    BSTree T;
    createTree(T);
    cout<<"以中序遍历输出"<<endl;
    coutTree(T);
    return 0;
    }


    han.cpp:

    #include <iostream>
    using namespace std;


    typedef struct BSTNode 
    {
    int data;
    struct BSTNode *lchild,*rchild;
    }BSTNode,*BSTree;


    int InsertBST(BSTree &T,int e)
    {
    if(T == NULL)
    {
    T = new BSTNode;
    T->data = e;
    T->lchild = T->rchild = NULL;
    return 1;
    }
    else if(e < T->data)
    {
    return InsertBST(T->lchild,e);
    }
    else if(e > T->data)
    {
    return InsertBST(T->rchild,e);
    }

    }


    void createTree(BSTree &T)
    {
    T = NULL;
    int e;
    cout<<"输入要创建的数据项"<<endl;
    cin>>e;
    while(e != 0)
    {
    int a = InsertBST(T,e);
    cin>>e;
    }
    }

    void coutTree(BSTree T)
    {
    if(T == NULL)
    {
    return ;
    }
    else
    {
    coutTree(T->lchild);
    cout<<T->data<<" ";
    coutTree(T->rchild);
    }
    }


    代码的实验结果:

    输入要创建的数据项
    12 7 17 11 16 2 13 9 21 4 
    0
    以中序遍历输出
    2 4 7 9 11 12 13 16 17 21

    这道题是用输入0来终止循环的,当然这样也是有弊端的,大家可以按照自己的方法来实现自己的想法,总体来说这个实验就是用递归的方法来实现创建以及输出的,对于数据结构来说,递归是比较重要的!希望大家好好的理解其中的过程,不懂得请留言我,希望给大家带来帮助!

    展开全文
  • 判断一棵二叉树是否为二叉排序树

    千次阅读 2020-03-24 11:43:07
    一棵空树,或者是具有下列性质二叉树: (1)若左子树不空,则左子树上所有结点值均小于它根结点值; (2)若右子树不空,则右子树上所有结点值均大于它根结点值; (3)左、右子树也分别为二叉排序树...

    【问题描述】
    一棵空树,或者是具有下列性质的二叉树:
    (1)若左子树不空,则左子树上所有结点的值均小于它的根结点的值;
    (2)若右子树不空,则右子树上所有结点的值均大于它的根结点的值;
    (3)左、右子树也分别为二叉排序树;
    (4)没有键值相等的结点。
    已知该二叉树中的数据都是整型,请设计算法判断一棵二叉树是否为二叉排序树。
    在这里插入图片描述
    扩展二叉树用-1表示某结点没有左/右孩子,该二叉树的扩展二叉树如下图示
    在这里插入图片描述
    扩展二叉树的前序遍历序列是:10 7 4 -1 -1 8 -1 9 -1 -1 -1。
    【输入形式】一行整数,该行是扩展二叉树的前序遍历序列,用于构造二叉树。
    【输出形式】该二叉树中是否是二叉排序树。如果是二叉排序树输出“YES”,否则输出“NO”。
    【样例输入】10 7 4 -1 -1 8 -1 9 -1 -1 -1
    【样例输出】
    YES

    分析:
    1.首先构建一棵二叉树
    2.根据二叉排序树的性质写一个判断函数
    3.通过函数判断是否为一颗二叉排序树

    实现:
    利用结构体构建结点 利用类构建树

    struct BiNode
    {
        int data;
        BiNode *rchild,*lchild;
    };
    class BiSortTree
    {
    public:
        BiSortTree()
        {
            root=creat();
            flag=true;
            p=-256;
        }
        bool IsBST()
        {
            return IsBST(root);
        }
        void InOrder()
        {
            InOrder(root);
        }
    private:
        BiNode*creat();//构建树的函数
        bool IsBST(BiNode*bt);//判断是否为二叉排序树的函数
        void InOrder(BiNode*bt);//打印输出树的函数,在本题中可以检查树是否被成功创建
        BiNode*root;
        int  flag ;
        int p;
    };
    

    creat 函数

    BiNode*BiSortTree::creat()
    {
        int a;
        BiNode *bt;
        cin>>a;
        if(a==-1)
        {
            bt=NULL;
        }
        else
        {
            bt=new BiNode;//如果不为空 新建一个结点
            bt->data=a;
            bt->lchild=creat();//递归调用
            bt->rchild=creat();
        }
        return bt;//不要忘了返回值为 BiNode 类型
    
    }
    

    判断是否为二叉排序树的函数

    bool BiSortTree::IsBST(BiNode*bt)
    {//根据二叉排序树的中序遍历为从大到小的顺序 进行递归
        if(bt->lchild!=NULL&&flag)//左
        {
            IsBST(bt->lchild);
        }
        if(p>bt->data)
            flag=false;
        p=bt->data;//根
        if(bt->rchild!=NULL&&flag){
            IsBST(bt->rchild);
        }
        return flag;
    }
    

    输出树中序遍历的函数

    void BiSortTree::InOrder(BiNode*bt)
    {
        if(bt==NULL)
            return;
        else
        {
            InOrder(bt->lchild);
            cout<<bt->data;
            InOrder(bt->rchild);
        }
    }
    

    主函数

    int main()
    {
        BiSortTree bst;
        //bst.InOrder();
        if(bst.IsBST())
        //判断的小技巧 bst.IsBST()为bool 类型 
        //if( bst.IsBST() ) <=> if( bst.IsBST() == true )
        //if( ! bst.IsBST() ) <=> if( bst.IsBST() == false )
            cout<<"YES";
        else
            cout<<"NO";
    }
    

    在下是一名小白 如果有不恰当的地方 欢迎指正

    展开全文
  • 平衡的二叉排序树

    2020-05-30 11:50:35
    问题:依次输入表(30,15,28,20,24,10,68,35,50)的元素,生成一棵平衡的二叉排序树。请画出构造过程,并在其中注明每一次平衡化的类型(LL型、RR型、LR型、RL型) 题目解析 本题考查的是二叉排序树和二叉平衡树的...

    平衡的二叉排序树

    问题:依次输入表(30,15,28,20,24,10,68,35,50)中的元素,生成一棵平衡的二叉排序树。请画出构造过程,并在其中注明每一次平衡化的类型(LL型、RR型、LR型、RL型)

    题目解析

    本题考查的是二叉排序树和二叉平衡树的相关知识点。首先,二叉排序树(又叫二叉搜索树)默认服从左小右大的树形排序结构,在一般情况下,查询效率比链表结构要高。并且服从以下性质:
    (1)若左子树不空,则左子树上所有结点的值均小于它的根结点的值;
    (2)若右子树不空,则右子树上所有结点的值均大于它的根结点的值;
    (3)左、右子树也分别为二叉排序树;
    (4)没有键值相等的结点。
    其次是二叉平衡树(AVL树)的相关知识,它具有以下特点:
    (1)本身首先是一棵二叉搜索树。
    (2)带有平衡条件:每个结点的左右子树的高度之差的绝对值(平衡因子)最多为1。

    题目答案注释(如有不对,欢迎批评指正)

    在这里插入图片描述
    在这里插入图片描述
    以上就是正确的解法

    AVL树求法分析

    首先先将所需要生成的树的元素一个一个插入,在插入的同时融合树型知识进行分析,核心要点是将左右树分开分析方可达到最好的效果

    1. 左旋(LL型)

    在这里插入图片描述
    2. 右旋(RR型)

    在这里插入图片描述
    3.先左旋后右旋(LR型)
    在这里插入图片描述
    4. 先右旋后左旋(RL型)
    在这里插入图片描述
    (图片来自网络)

    展开全文
  • Python实现二叉排序树

    2020-06-15 13:20:30
    二叉排序树中,如果其根结点有左子树,那么左子树上所有节点值都小于根结点值; 二叉排序树中,如果其根结点有右子树,那么右子树上所有节点值都大于根结点值; 二叉排序树左右子树也要求都是二叉排序树。...

    一、什么是二叉排序树?

    二叉排序树要么是一棵空二叉树,要么是具有如下特点的二叉树:

    • 二叉排序树中,如果其根结点有左子树,那么左子树上所有节点的值都小于根结点的值;
    • 二叉排序树中,如果其根结点有右子树,那么右子树上所有节点的值都大于根结点的值;
    • 二叉排序树的左右子树也要求都是二叉排序树。

    如下图所示:
    在这里插入图片描述在这里插入图片描述

    二、二叉排序树的Python实现

    二叉排序树的插入

    插入: 从根结点开始逐个与关键字进行比较,小于根结点去左边,大于根结点去右边,碰到子树为空的情况指向关键字。

    class Node(object):
        """二叉树节点的封装"""
    
        def __init__(self, element=None, lchild=None, rchild=None):
            self.element = element
            self.lchild = lchild
            self.rchild = rchild
    
        def __str__(self):
            return '<node:%d>' % (self.element)
    
    class BinarySortTree(object):
        """二叉排序树的封装"""
        def __init__(self):
            self.root = None
    
        def is_empty(self):
            return self.root == None
    
        def __add__(self, item):
            """
            树里面插入元素:
                1. 如果为空二叉树,将根节点指向插入元素的节点
                2. 如果不为空,与根结点进行大小比较,大于根结点寻找右子树,小于根结点寻找左子树
            :param item:
            :return:
            """
            node = Node(item)
            if self.is_empty():
                self.root = node
            bt = self.root
            while True:
                rootItem = bt.element
                # 如果节点元素大于插入元素,寻找左子树
                if rootItem > item:
                    if bt.lchild == None:
                        bt.lchild = node
                    bt = bt.lchild
                # 如果节点的元素小于插入元素,寻找右子树
                elif rootItem < item:
                    if bt.rchild == None:
                        bt.rchild = node
                    bt = bt.rchild
                else:
                    return
    
        def breadth_travel(self):
            """利用队列实现树的层次遍历"""
            if self.is_empty():
                return
            queue = []
            queue.append(self.root)
            while queue:
                cur = queue.pop(0)
                print(cur.element, end=',')
                if cur.lchild != None:
                    queue.append(cur.lchild)
                if cur.rchild != None:
                    queue.append(cur.rchild)
            print()
    

    二叉排序树的查找

    查找: 对比节点的值和关键字,相等则表明找到了,输出该节点;小于节点的值,则往节点的左子树去寻找,大于节点的值,则往右子树去寻找,这样递归下去,最后返回布尔值或者找到的节点。

        def searchDetail(self, root, parent, key):
            """
            搜索指定元素是否在树里面
            :param root: 根结点
            :param parent: 父节点
            :param key: 用户搜索的元素
            :return:返回parent是为了方便下边的删除
            """
            if self.is_empty():
                return False, root, parent
            while root:
                # 如果找到的节点元素和用户搜索的相等,直接返回节点对象
                if root.element == key:
                    return True, root, parent
                # 如果找到的节点元素大于用户搜索的值,往节点的左子树继续寻找
                elif root.element > key:
                    parent = root
                    root = root.lchild
                # 如果找到的节点元素小于用户搜索的值,往节点的右子树继续寻找
                else:
                    parent = root
                    root = root.rchild
            return False, root, None
    

    二叉排序树的删除

    1、 删除节点为叶子节点
    删除的节点没有左子树也没有右子树,也就是删除的节点为叶子节点。有两种情况:
     1. 该叶子节点为二叉排序树的根结点,也就是二叉排序树中只有一个结点,只需要将root的指针置为空即可
     2. 该叶子节点有父节点,将父节点的连接该删除节点的指针置为空即可。

    2、删除的节点只有左子树或者只有右子树
    删除节点后,将父节点指针指向子树即可

    3、同时存在左右子树
    如果同时存在左右子树,则可以将二叉排序树进行中序遍历,取将要被删除的节点的前驱或者后继节点替代这个被删除的节点的位置。

    方法一: 令结点 p 的左子树为其双亲结点的左子树;结点 p 的右子树为其自身直接前驱结点的右子树,简单来说就是选择删除节点的左子树的最大值来补上。
    在这里插入图片描述
    同理,如果删除节点是根结点的右子树节点,令节点p的右子树为其双亲节点的右子树,令节点p的左子树为自身后继节点的左子树。简单来说就是另选择删除节点的右子树的最小值来补上。

        def __delete__(self, key):
            """
            删除二叉排序树的节点元素:
                1. 如果删除的是叶子节点,直接删除
                2. 如果只有左子树或者右子树,则删除节点后,将子树链接到父节点即可
                3. 既存在左子树又存在右子树,两种方法解决
            :param key:
            :return:
            """
            # 查找删除元素对应的节点,获取其是否存在,获取节点和其父节点
            isExist, node, parentNode = self.searchDetail(self.root, None, key)
            # 如果节点不存在
            if not isExist:
                print('要删除的元素%d不存在' %(node.element))
                return
            # 如果不存在根
            if not self.root:
                print('thr tree is null')
                return
            # 如果处理的是根节点,不处理
            if node == self.root:
                print('不能删除根节点')
                return
            # 1.如果删除的是叶子节点,根据其父节点删除
            if not node.lchild and not node.rchild:
                # 判断是父节点的右孩子还是左孩子
                if parentNode.rchild == node:
                    parentNode.rchild = None
                if parentNode.lchild == node:
                    parentNode.rchild = None
            # 2.如果只存在右子树或者左子树,将节点的子节点链接到父节点上,将节点删除
            # 如果是右子树
            if not node.lchild and node.rchild:
                parentNode.rchild = node.rchild
            # 如果是左子树
            if not node.rchild and node.lchild:
                parentNode.lchild = node.lchild
    
            # 3.左右子树皆存在
            if node.lchild and node.rchild:
                # 分类讨论,删除的是父节点的左孩子还是右孩子
                # 如果找到了node的直接父节点,令节点node的左子树为其双亲节点的左子树,
                # 将node的左子树的右子树的最右节点指向node的右子树
                if parentNode.lchild == node:
                    parentNode.lchild = node.lchild
                    prevNode = node.lchild
                    while prevNode.rchild:
                        prevNode = prevNode.rchild
                    # prevNode指的是node节点的直接前驱(中序遍历时,node节点前面的节点)
                    prevNode.rchild = node.rchild
    			# 如果删除的是父节点的右孩子,将父节点的右孩子指向node节点的右孩子
    			# 将node节点的右孩子的左子树的最左节点指向node的左子树
                elif parentNode.rchild == node:
                    parentNode.rchild = node.rchild
                    prevNode = node.rchild
                    # prevNode指的是node节点的直接后继(中序遍历时,node节点后面的节点)
                    while prevNode.lchild:
                        prevNode = prevNode.lchild
                    prevNode.lchild = node.lchild
    
    

    方法二: 用结点 p 的直接前驱(或直接后继)来代替结点 p,同时在二叉排序树中对其直接前驱(或直接后继)做删除操作。在对左图进行中序遍历时,得到的结点 p 的直接前驱结点为结点 s,所以直接用结点 s 覆盖结点 p

    在这里插入图片描述
    方法二的代码类似于方法一,这里就不再编写了。

    大体思路:

    先找到node节点的左子树的右子树的最右节点(就是找到小于删除节点但最接近删除节点大小的节点),让这个最右节点的父节点的右孩子指向最右节点的左孩子,让node的父节点的左孩子指向node节点的左子树的右子树的最右节点,这个最右节点的左孩子指向node节点的左孩子,右孩子指向node节点的右孩子。

    测试代码:

    if __name__ == '__main__':
        binarySortedTree = BinarySortTree()
        nums = [6, 4, 2, 3, 5, 8, 7, 9]
        for num in nums:
            binarySortedTree.__add__(num)
        # binarySortedTree.__add__(4)
        # binarySortedTree.__add__(6)
    
        binarySortedTree.breadth_travel()
        root = binarySortedTree.root
        print('详细搜索....')
        isExist, node, parentNode = binarySortedTree.searchDetail(root, None, 7)
        print('搜索结果:',isExist)
        print("找到的节点:" ,node)
        print('搜索节点的父节点:', parentNode)
    
        # binarySortedTree.__delete__(2)
        # binarySortedTree.breadth_travel()
        binarySortedTree.__delete__(8)
        binarySortedTree.breadth_travel()
    
    	
    	6,4,8,2,5,7,9,3,
    	详细搜索....
    	搜索结果: True
    	找到的节点: <node:7>
    	搜索节点的父节点: <node:8>
    	6,4,9,2,5,7,3,
    
    展开全文
  • 上一篇介绍了二分查找递归和非递归写法,这一篇文章主要记录二叉排序树中查找元素递归和非递归写法。二叉排序树又称为二叉查找树,也称为二叉搜索树。 二叉排序树或者是一棵空树,或者是具有下列性质二叉树:...
  • 二叉搜索树或者是一棵空树,或者是具有下列性质二叉树: 每个结点都有一个作为搜索依据关键码(key),所有结点关键码互不相同。(即BST树中所有元素值不允许重复) 左子树(如果存在)上所有结点关键码...
  • 二叉排序树 从一棵空树开始创建,在创建过程,保证树的有序性,同时还要针对树的平衡性做些调整。最终要把创建好的二叉排序树转换为二叉平衡排序树。
  • 描述 在给定的二叉排序树中查找指定的元素。不考虑树情况。输入 输入为n+2行。第一行为测试数据的组数n,第二行为一棵用广义表表示的二叉排序树,树中元素为int。以下n行为n组测试数据,数据为int。输出 输出为n行...
  • 二叉排序树的时间复杂度

    万次阅读 2018-04-12 11:24:21
    二叉排序树又称二叉查找树,它或是一棵空的二叉树,或是具有下列性质的二叉树: 若它的左子树不空,则左子树上所有节点的值均小于根节点的值若它的右子树不空,则右子树上所有节点的值均大于根节点的值它的左右子树...
  • 一棵树若为二叉排序树,需要满足以下条件: 为树或者是二叉树 如果左子树不,则左子树上所有节点值都小于根节点值。 如果右子树不,则右子树上所有节点值都大于根节点值。 左子树和右子树也同样是...
  • binary search tree,中文翻译为二叉搜索树、二叉查找树或者二叉排序树。简称为BST 一:二叉搜索树定义 他定义与树定义是类似,也是一个递归定义: 1、要么是一棵空树 2、如果不为空,那么其...
  • binary search tree,中文翻译为二叉搜索树、二叉查找树或者二叉排序树。简称为BST 一:二叉搜索树定义 他定义与树定义是类似,也是一个递归定义: 1、要么是一棵空树 2、如果不为空,那么其左子树...
  • 给定个数组,如何构造二叉排序树(ADL)

    万次阅读 多人点赞 2016-09-26 11:54:11
    构造一棵二叉排序树就是依次输入数据元素,将它们插入到二叉排序树中的适当位置上过程。具体过程是:每次读入一个元素,就建立一个新节点,若二叉排序树非空,则将新节点值与根节点值比较,如果小于根节点...
  • 二叉排序树中,若按中序遍历就可以得到由小到大的有序序列,如图2.41中的二叉排序树,中序遍历可得到有序序列{2,3,4,8,9,9,10,13,15,18,21}。 (2)二叉排序树的生成 二叉排序树是种动态表结构,即二
  • think: 1 判断两个二叉搜索树是否相同的函数注意判断二叉搜索树rt1和二叉搜索树rt2是否为sdut原题链接数据结构实验之查找一:...然而,一棵给定的二叉排序树却可以由多种不同的序列得到。例如分别按照序列{3,1,
  • 简称为BST 一:二叉搜索树的定义 他定义与树的定义是类似,也是一个递归定义: 1、要么是一棵空树 2、如果不为空,那么其左子树节点值都小于根节点值;右子节点值都大于根节点值 3、其左右子树也是...
  • 二叉排序树 二叉排序树(Binary sort tree,BST),又叫二叉查找树、二叉搜索树...(注:二叉排序树中没有值相同节点) 二叉排序树属于种动态查找表, 关于二叉排序树节点代码实现: public class TreeNode { p
  • 二叉排序树的构造及其基本操作

    千次阅读 2020-11-11 18:21:02
    二叉排序树的定义 对于一棵空的二叉树或者...二叉排序树中对值的查找 给定一个值p,当前结点为bt,若bt->data==p,查找成功。 若pdata,则在pt左子树查找。 若p>bt->data,则在pt右子树查找。 BiNode* BiSortTree
  • 二叉排序树或者是一棵空树,或者是具有如下特性二叉树: 若左子树不空,则左子树上所有结点值均小于或等于根结点值; 若右子树不空,则右子树上所有结点值均大于或等于根结点值; 左、右子树也分别为...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 498
精华内容 199
关键字:

一棵空的二叉排序树中