精华内容
下载资源
问答
  • 它或则是一颗空树,或者是带有以下性质的二叉树:构造二叉排序树的目的,并不是为了顺序,而是为了提升查找和插入删除关键字的速度。以下程序在DEV C++中安装运行通过。#include#include/*二叉树的二叉链表结点结构...

    adea9c46487c8f563eeee8eb0c077ffc.png

    本文链接:

    1e891a43f3d1c7978d3691bdf7d10b78.png

    二叉排序树(Binary Sort Tree)c语言 二叉排序树,又称为二叉查找树。它或则是一颗空树,或者是带有以下性质的二叉树:

    03330ec49a5eaab0f324fa33d918e755.png

    构造二叉排序树的目的,并不是为了顺序,而是为了提升查找和插入删除关键字的速度。

    09a8ce33c10490b8ab645d15909315.jpg

    以下程序在DEV C++中安装运行通过。

    img_1_3505939222D148940721_26.jpg

    #include

    #include

    /*二叉树的二叉链表结点结构定义*/

    typedef struct BiTNode

    {

    int data;

    struct BiTNode *lchild,*rchild;

    }BiTNode,*BiTree;

    /*递归查找二叉排序树T中是否存在key,指针f指向T的双亲,其初始调用值为NULL,若查找成功,则指针P指向该数据元素结点,并返回1,否则指针p指向查找路径上访问的最后一个节点并返回0*/

    int SearchBST(BiTree T,int key,BiTree f,BiTree *p)

    {

    if(!T)//查找不成功

    {

    *p=f;

    return 0;

    }

    else if(key==T->data)//查找成功

    {

    *p=T;

    return 1;

    }

    else if(keydata)

    return SearchBST(T->lchild,key,T,p);//在左子树继续查找

    else

    return SearchBST(T->rchild,key,T,p);//在右子树继续查找

    }

    /*当二叉排序树T中不存在关键字等于key的数据元素时,插入key并返回1,否则返回0*/

    int InsertBST(BiTree *T,int key)

    {

    BiTree p,s;

    if(!SearchBST(*T,key,NULL,&p))//查找不成功

    {

    s=(BiTree)malloc(sizeof(BiTNode));

    s->data=key;

    s->lchild=s->rchild=NULL;

    if(!p)

    *T=s;//插入s为新的根结点

    else if(keydata)

    p->lchild=s;//插入s为左孩子

    else

    p->rchild=s;//插入s为右孩子

    return 1;

    }

    else

    return 0;

    }

    /*若二叉排序树T中存在关键字key的数据元素时,则删除该数据元素节点,并返回1;否则返回0*/

    int DeleteBST(BiTree *T,int key)

    {

    if(!T)

    return 0;

    else

    {

    if(key==(*T)->data)

    return Delete(T);

    else if(keydata)

    return DeleteBST(&(*T)->lchild,key);

    else

    return DeleteBST(&(*T)->rchild,key);

    }

    }

    int Delete(BiTree *p)

    {

    BiTree q,s;

    if((*p)->rchild==NULL)//右子树为空只需重接它的左子树

    {

    q=*p;*p=(*p)->lchild;free(q);

    }

    else if((*p)->lchild==NULL)

    {

    q=*p;*p=(*p)->rchild;free(q);

    }

    else//左右子树均不空

    {

    q=*p;s=(*p)->lchild;

    while(s->rchild)

    {

    q=s;s=s->rchild;

    }

    (*p)->data=s->data;

    if(q!=*p)

    q->rchild=s->lchild;

    else

    q->lchild=s->lchild;

    free(s);

    }

    return 1;

    }

    int main()

    {

    int i,j;

    int a[10]={62,88,58,47,35,73,51,99,37,93};

    BiTree T=NULL,p;

    //二叉排序树的插入和创建

    for(i=0;i<10;i++)

    {

    InsertBST(&T,a[i]);

    }

    j=SearchBST(T,51,NULL,&p);

    if(j=1)

    printf("搜索51成功!");

    j=DeleteBST(&T,47);

    if(j=1)

    printf("删除47成功!");

    }运行结果如图所示。

    df3d1da14de586bee8139617bc9e6ce1.png

    二叉排序树的查找性能取决于二叉排序树的颜色c语言 二叉排序树,二它的外形是不确定的。极端右斜树的查找时间复杂度为O(n),等同于顺序查找;而平衡二叉树的查找时间复杂度为O(logn),等同于折半查找。

    本文来自电脑杂谈,转载请注明本文网址:

    http://www.pc-fly.com/a/jisuanjixue/article-120513-1.html

    展开全文
  • 给定序列 6 8 5 7 9 3构建二叉排序树 并画出先序索二叉树
    展开全文
  • 文章目录二叉排序树1. 二叉排序树2. 平衡二叉排序树 二叉排序树 1. 二叉排序树 二叉排序树的检索 def bt_search(btree, key): bt = btree: while bt: if key < bt.val: bt = bt.left elif key > bt.val: ...

    二叉排序树

    1. 二叉排序树

    二叉排序树的检索

    def bt_search(btree, key):
        bt = btree:
        while bt:
            if key < bt.val:
                bt = bt.left
            elif key > bt.val:
                bt = bt.right
            else:
                return bt.val
        
        return None
    

    二叉排序树数据插入
    思路:

    • 若树为空,直接新建结点
    • 若树不为空:
      • 应该向左走而左结点为空,插入;
      • 应该向右走而右结点为空,插入;
      • 覆盖原有结点
    def bt_insert(btree, key):
        if btree is None:
            return TreeNode(key)
        bt = btree
        while True:
            if key < bt.val:
                if bt.letf is None:
                    bt.left = TreeNode(key)
                    return btree
                bt = bt.left
            elif key > bt.val:
                if bt.right is None:
                    bt.right = Tree.Node(key)
                    return btree
                bt = bt.right
            else:
                bt.val = key
                return btree
    

    二叉排序树数据删除
    思路:

    • 找到待删除数值和它的父节点在树中的位置
    • 若子结点的左子树为空,则直接将子节点的右子树挂到父节点,此处有3种情况
      • 父节点为空(子节点为根节点),则直接将根节点设为子节点的右子树
      • 子节点是父节点的左结点,则将子节点的右子树挂到父节点的左结点
      • 子节点是父节点的右结点,则将子节点的右子树挂到父节点的右结点
    • 若子节点的左子树不为空,先找到左子树的最右结点,并将子节点的右子树挂到最右结点的右结点上,后续同样有三种情况
      • 父节点为空(子节点为根节点),则直接将根节点设为子节点的左子树
      • 子节点是父节点的左结点,则将子节点的左子树挂到父节点的左结点
      • 子节点是父节点的右结点,则将子节点的左子树挂到父节点的右结点

    def delete(btree, key):
        bt = btree
        father, child = None, btree
        while child and child.val != key:
            father = child
            if key < child.val:
                child = child.left
            elif key > child.val:
                child = child.right
        if child is None:
            return 
        
        # 子节点左子树为空
        if child.left is None:
            if father is None:
                btree = child.right
            elif child is father.left:
                father.left = child.right
            else:
                father.right = child.right
            return btree
    
        # 子节点左子树不为空
        most_right = child.left
        while most_right.right:
            most_right = most_right.right
        
        most_right.right = child.right
        if father is None:
            btree = child.left
        elif child is father.left:
            father.left = child.left
        else:
            father.right = child.left
        return btree
    

    2. 平衡二叉排序树

    记结点左子树和右子树的高度差为平衡因子(Balance Factor),平衡因子的取值为-1,0,1.

    • 如果数据插入位置到根节点途径上每一个结点的BF都为0,那么新插入的结点不会影响导致树失衡,此时只需更新途径上结点的BF值即可.
    • 如果途径上结点BF值不全为0,则可以从插入节点位置沿着途径向上查找,找到第一个BF值不为0的结点,以该节点为根节点的树称为最小非平衡子树,后续的调整都在最小非平衡子树上进行. 记最小非平衡子树的根节点为a, 有左右两棵子树,BF都为0,但两棵树高度差1
      • 如果数据插入较低子树,则a的高度不变,且BF变为0.只需调整插入位置到a路径上结点的BF值即可,其他结点的BF值不变
      • 如果数据插入较高子树,则要调整高子树一部分数据到低子树中,以平衡高度.
        • LL型调整,a左子树较高,新节点插入到左子树的左子树
        • LR型调整,a左子树较高,新节点插入到左子树的右子树
        • RR型调整,a右子树较高,新节点插入到右子树的左子树
        • LL型调整,a右子树较高,新节点插入到左子树的左子树

    LL调整

    (1) 插入结点前,中序遍历的序列为 AbBaCA b B a C
    (2) 插入结点后,导致结点a的BF变为2,不满足平衡二叉树的要求
    (3) 要保持中序遍历的顺序不变,AbBaCA^{\prime} b B a C,将b作为最小非平衡子树的根节点,AA^{\prime}为左子树,BaCBaC为右子树,即可达到平衡.

    给树节点增加一个BF属性:

    class TreeNode():
        def __init__(self, x):
            self.val = x
            self.left = None
            self.right = None
            self.bf = 0
    

    LL调整python实现:

    def LL(a, b):
        a.left = b.right
        b.right = a
    
        a.bf = 0
        b.bf = 0
        return b
    

    RR调整
    RR调整与LL调整类似:

    def RR(a, b):
        a.right = b.left
        b.left = a
    
        a.bf = 0
        b.bf = 0
        return b
    

    LR调整

    (1) 记根节点a左子树的右子树的根节点为c.由于a是最小非平衡子树的跟,所以b,c的bf都为0,以a为根的中序遍历序列是AbBcCaDAbBcCaD
    (2) 新节点可能插入c的左子树(B)或右子树©,插入后b结点的BF=-1, a结点的BF为2,失衡!
    (3) 将c提升为最小非平衡子树的根节点,左右结点分别为b,a,如图所示,中序遍历的结果为AbBcCaDAbB^{\prime}cCaDAbBcCaDAbBcC^{\prime}aD,保持不变,且c结点BF变为0,b和a结点的BF为-1,0或者1,取决于新节点位置.

    def LR(a,b):
        c = b.right
        b.right = c.left
        c.left = b
        a.left = c.right
        c.right = a
    
        # 以下情况是失衡后二叉树的情况
        if c.bf == 0:# c本身为插入节点
            a.bf = b.bf = 0
        elif c.bf == 1: # 新节点在左子树
            b.bf = 0
            a.bf = -1
        else:   # 新节点在右子树
            b.bf = -1
            a.bf = 0
        
        c.bf = 0
        return c
    

    c本身为插入结点的情况如下:

    RL调整

    def RL(a,b):
        c = b.left
        b.left = c.right
        c.right = b
        a.right = c.left
        c.left = a
    
        if c.bf == 0:
            a.bf = b.bf = 0
        elif c.bf == 1:
            a.bf = 0
            b.bf = -1
        else:
            a.bf = -1
            b.bf = 0
        c.bf = 0
        return c
    

    平衡二叉排序树的插入操作:

    • 查找新节点的插入位置,并在查找过程中记录最小不平衡子树的根
    • 修改插入位置到最小不平衡子树根路径上各节点的平衡因子
    • 检查以a为根的子树是否失衡,若失衡则依据情况进行调整.
    def insert(btree, key):
        if btree is None:
            return TreeNode(key)
        a = btree   # 最终是最小不平衡树的根
        p = btree   # 指针
        fa = None   # a的父节点
        q = None    # p的父节点
    
        # 1. 查找插入位置并记录最小非平衡树根节点
        while p:
            # 若BF值不为0,则有可能为最小不平衡树的结点
            if p.bf != 0:
                fa, a = q, p
            
            # 查找插入位置:
            if p.val == key:
                return btree
            elif key < p.val:
                q = p
                p = p.left
            else:
                q = p
                p = p.right
        # 2. 插入节点
        # 此时q是待插入结点的父节点
        node = TreeNode(key)
        if key < q.val:
            q.left = node
        else:
            q.right = node
        
        # 3. 更新BF值,只需更新插入位置到a结点路径上结点的BF值.
        # 先判断插入节点在a的左子树还是右子树
        if key < a.val:
            p = a.left  # 指针
            b = a.left  # a深度较大子树的根节点,用于后续调整
            d = 1
        else:
            p = a.right
            b = a.right
            d = -1
    
        while p != node:
            if key < p.val:
                p.bf = 1    # p原来BF为0
                p = p.left
            else:
                p.bf = -1
                p = p.right
            
        # 4. 判断是否需要调整
        if a.bf == 0:   # a本身平衡,无需调整
            a.bf = d
            return btree
        elif a.bf == -d:    # 增加的结点在较低的树上,无需调整
            a.bf = 0
            return btree
        else:   # 增加的结点在较高的树上
            if d == 1:  # 增加在左子树
                if b.bf == 1: # 增加在左子树的左子树
                    b = LL(a, b)
                else:   # 增加在左子树的右子树
                    b = LR(a, b)
            else:
                if b.bf == 1:
                    b = RL(a, b)
                else:
                    b = RR(a, b)
        
        # 5.将调整好的树接回去
        # a为根节点
        if pa is None:
            btree = b
        elif pa.left == a:
            pa.left = b
        else:
            pa.right = b
        
        return btree
    
    展开全文
  • 构造二叉排序树,然后中序遍历

    千次阅读 2016-02-25 11:21:48
    package main import ( "unsafe" "fmt" "math/rand" "time" ) type TreeNode struct { x int lchild *TreeNode rchild *TreeNode } ... if x...
    package main
    
    import (
    	"unsafe"
    	"fmt"
    	"math/rand"
    	"time"
    )
    
    type TreeNode struct {
    	x int
    	lchild *TreeNode
    	rchild *TreeNode
    }
    
    type Tree TreeNode
    
    func appendNode(node *TreeNode,x int)  {
    	if x>=node.x {
    		if node.lchild==nil {
    			node.lchild=&TreeNode{x,nil,nil}
    		} else {
    			appendNode(node.lchild,x)
    		}
    	} else {
    		if node.rchild==nil {
    			node.rchild=&TreeNode{x,nil,nil}
    		} else {
    			appendNode(node.rchild,x)
    		}
    	}
    }
    
    func createTree(x []int) *Tree {
    	root:=&TreeNode{x[0],nil,nil}
    	for i:=1; i<len(x); i++ {
    		appendNode(root,x[i])
    	}
    	return (*Tree)(unsafe.Pointer(root))
    }
    
    func travel(tree *Tree)  {
    	root:=(*TreeNode)(unsafe.Pointer(tree))
    	if root.lchild!=nil {
    		travel((*Tree)(unsafe.Pointer(root.lchild)))
    	}
    	fmt.Print(root.x," ")
    	if root.rchild!=nil {
    		travel((*Tree)(unsafe.Pointer(root.rchild)))
    	}
    }
    
    func main()  {
    	rand.Seed(time.Now().UnixNano())
    	x:=make([]int,10)
    	for i:=0; i<len(x); i++ {
    		x[i]=rand.Intn(100)
    	}
    	fmt.Println(x)
    	tree:=createTree(x)
    	travel(tree)
    }

     

    展开全文
  • 二叉排序树(二叉查找树)--查找 注:构造一棵二叉排序树的目的,其实并不是为了排序(中序遍历),而是为了提高查找、插入、删除关键字的速度。定义 二叉排序树又叫二叉查找树,英文名称是:Binary Sort Tree.BST的定义...
  • 给定一个数组,如何构造一个二叉排序树(ADL)

    万次阅读 多人点赞 2016-09-26 11:54:11
    构造二叉排序树 构造一棵二叉排序树就是依次输入数据元素,将它们插入到二叉排序树中的适当位置上的过程。具体过程是:每次读入一个元素,就建立一个新的节点,若二叉排序树非空,则将新节点的值与根节点的值比较,...
  • Python实现二叉排序树

    2020-06-15 13:20:30
    一、什么是二叉排序树二叉排序树要么是一棵空二叉树,要么是具有如下特点的二叉树: 二叉排序树中,如果其根结点有左子树,那么左子树上所有节点的值都小于根结点的值; 二叉排序树中,如果其根结点有右子树,...
  • 二叉排序树

    千次阅读 多人点赞 2019-07-26 18:14:27
    一、二叉排序树的定义 二叉排序树(BST),也叫二叉查找树。二叉排序树或者是一颗空树,或者是一颗具有下列特性的非空二叉树: 1.若左子树非空,则左子树上所有结点关键字值均小于根结点的关键字值; 2.若右子...
  • 一、问题描述 根据给定的关键字序列,实现二叉排序树的基本操作。 输入格式:8, 10, 5, 6, 3, 13 二、实验目的 ...1、构造二叉排序树的存储结构。 2、实现创建、查找、插入、删除、平均查找长度等操作。
  • 二叉排序树1、定义2、性质3、操作3.1 查找 1、定义 \quad \quad二叉排序树又称二叉搜索树、二叉查找树。 \quad \quad二叉排序树或是空树,或是满足以下性质的二叉树: (1)若其左子树非空,则左子树上所有结点的值...
  • 文章目录二叉搜索树/二叉排序树/二叉查找树.1 定义.2 性质二叉搜索树创建二叉搜索树查找.1 查找步骤.2 查找性能分析二叉树插入与删除 二叉搜索树/二叉排序树/二叉查找树 .1 定义 二叉排序树(Binary Sort Tree)...
  • 108 根据有序数组构造平衡的二叉排序树 点击此处返回总目录 ... 109 根据有序链表构造平衡的二叉排序树 一、108 根据有序数组构造平衡的二叉排序树 【题目】 ...
  • 关键字序列1,2,3,4,5构造而得的二叉排序树 ASL=(1,2,3,4,5)/5=3 按关键字3,1,2,5,4构造而得的二叉排序树 ASL=(1+2+2+3+3)/5=2.2 很明显第二种序列的ASL要快。至于二叉排序树怎么构成的其实就是根据它的性质(若...
  • 二叉排序树中查找某关键字时,查找过程类似于次优二叉树,在二叉排序树不为空树的前提下,首先将被查找值同树的根结点进行比较,会有 3 种不同的结果: 如果相等,查找成功; 如果比较结果为根结点的关键字....
  • 二叉排序树的目的不是为了排序,而是为了提高查找(有序)、和删除关键字(树型结构)的速度; 特点:左子树<根节点<右子树 1.构造一颗二叉排序树 bool create_BST(BiTree &T,Elem *elem_list,int n){//...
  • 二叉排序树 Time Limit: 1000 ms Memory Limit: 65536 KiB Submit Statistic Discuss Problem Description 二叉排序树的定义是:或者是一棵空树,或者是具有下列性质的二叉树: 若它的左子树不空,则左子树上...
  • [题目] 设在一棵二叉排序树的每个结点中,含有关键字值key域和统计相同关键字值结点个数的count域 当向该树插入一个元素时 若树中已存在该元素的关键字值相同的结点,则使该结点的count域增1 否则就由该元素生成...
  • 输入一组无序关键字(整数)序列构造一棵二叉排序树并对其进行中序遍历输出;在二叉排序树中查找某一关键字,若存在,显示查找成功;若不存在,将其插入到二叉排序树中,再中序遍历输出。 二叉排序树就是将一组数据...
  • 二叉搜索树(BST,Binary Search Tree),也称为二叉查找树或二叉排序树 二叉搜索树:一颗二叉树,可以为空;如果不为空,满足以下性质: 非空左子树的所有键值小于其根结点的键值 非空右子树的所有键值大于其根...
  • 二叉排序树(BST)构造与应用

    万次阅读 多人点赞 2016-03-20 23:23:46
    二叉排序树(BST)构造与应用     二叉排序树(BST):又称二叉查找树,其定义为:二叉排序树或者是空树,或者是满足以下性质的二叉树。  (1) 若它的左子树非空,则左子树上所有记录的关键字均小于根记录的值。  (2)...
  • 解析:高度最大为n,因为n个不同的数可以是递减或递增,即其高度不会超过n,而高度最少的话,我们可以想到:当这n个不同的数排成满二叉树时,高度就应该是最小的,可设高度为h,则有:(2^h) -1 = n,解出h,记得往上...
  • 二叉排序树 二叉排序树(Binary Sort Tree),又称为二叉查找树;它是一棵空树或着是具有下列性质的二叉树: 若左子树不空,则左子树上所有结点的值均小于它的根结点的值; 若右子树不空,则右子树上所有结点的值均...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,218
精华内容 4,087
热门标签
关键字:

关键字构造二叉排序树