二叉排序树和二叉平衡树

最新推荐文章于 2022-04-09 22:15:02 发布
最新推荐文章于 2022-04-09 22:15:02 发布
阅读量418 收藏 7
点赞数
分类专栏： C++ 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/likang500/article/details/111631229
版权

(1)给定一组数
(2)编程实现二叉排序树的创建、插入、删除和查询
(3)编程实现二叉平衡树的创建、插入、删除和查询
(4)对于给定的这组数分别在二叉排序树和二叉平衡树上进行查找，给出两种情况下的查找成功和不成功时的ASL

由于程序有些问题，输入的学号和成绩需要相同

代码结构

代码如下

BST.h

#ifndef BST_H_INCLUDED
#define BST_H_INCLUDED
struct student
{
    char num[6];
    int grade;
};
typedef struct BSTree
{
    struct student data;
    struct BSTree *lchild;
    struct BSTree *rchild;
} BNode,*BTree;
BTree Insert(BTree T,char nums[],int grades); //²åÈë
BTree Creat(BTree T,int n);//´´½¨
void midput(BTree T);
void firstput(BTree T);
void Search(BTree T,char num[]); //²éÕÒ
int Delete(BTree T,char * num,int key);
void save(BTree T,char num[][20],int grade[]);
void book();
//*******************************************************
typedef struct Node
{
    struct student data;
    struct Node *left;
    struct Node *right;
    int height;
}BTNode;
BTNode * CreatA(BTNode *T,int n);
BTNode* insertA(BTNode* node,char *num,int key);
void midputA(BTNode *T);
void firsputA(BTNode *T);
int height(struct Node *N);
int max(int a, int b);
int getBalance(BTNode* N);
BTNode* ll_rotate(BTNode* y);
BTNode* rr_rotate(BTNode* y);
BTNode* DeleteA(BTNode* root,char *num, int key);
void SearchA(BTNode *T,char num[]);
BTNode* newNode(char *num,int key);
BTNode * minValueNode(BTNode* node);



#endif // BST_H_INCLUDED

main.cpp

#include <bits/stdc++.h>
#include "BST.h"

using namespace std;

double NumOfASL_BST=0;
double NumOfASL_AVL=0;
int NumOfASL_BST_flag=0;
int NumOfASL_AVL_flag=0;

int main()
{
    BTree T=NULL;
    BTNode *TA=NULL;
    int grade,
        order;
    double  NOfSearch_AVL_Succes=0,//次数
        NOfSearch_AVL_Fail=0,
        NumOfASL_AVL_Last=0,//长度
        NumOfASL_AVL_Fail=0,

        NOfSearch_BST_Succes=0,
        NOfSearch_BST_Fail=0,
        NumOfASL_BST_Last=0,
        NumOfASL_BST_Fail=0;
    char num[6];
    while(1)
    {
        book();
        cin>>order;
        if(order==1)//建立
        {
            int NumOfStudent;
            cout<<"请输入学生数"<<endl;
            cin>>NumOfStudent;
            cout<<"请输入学号和成绩 用空格隔开"<<endl;
            T=Creat(T,NumOfStudent);
        }
        if(order==2)//遍历
        {
            cout<<"中序："<<endl;
            midput(T);
            cout<<"前序："<<endl;
            firstput(T);
        }
        if(order==3)//插入
        {
            cout<<"请输入要插入的学生信息"<<endl;
            cin>>num>>grade;
            T=Insert(T,num,grade);
            if(T!=NULL)
            cout<<"插入成功！"<<endl;
            else
            cout<<"插入失败!"<<endl;;
        }
        if(order==4)//删除
        {
            cout<<"请输入要删除的学生学号和成绩"<<endl;
            cin>>num>>grade;
            if(Delete(T,num,grade)==1)
                cout<<"删除成功!"<<endl;
            else
                cout<<"删除失败!"<<endl;
        }
        if(order==5)//查询
        {
            NumOfASL_BST_flag=0;
            cout<<"请输入要查询的学生的学号"<<endl;
            cin>>num;
            NumOfASL_BST_Last=NumOfASL_BST;
            Search(T,num);
            if(NumOfASL_BST_flag==0)
            {
                NumOfASL_BST_Fail =NumOfASL_BST_Fail + (NumOfASL_BST - NumOfASL_BST_Last);
                NOfSearch_BST_Fail++;
                cout<<"查找失败！"<<endl;
                NumOfASL_BST=NumOfASL_BST_Last;
            }
            else
            {
                NOfSearch_BST_Succes++;
            }
            cout<<"查询成功的总长度："<<NumOfASL_BST<<endl;
            cout<<"查询失败的总长度："<<NumOfASL_BST_Fail<<endl;
            cout<<"查询成功的n："<<NOfSearch_BST_Succes<<endl;
            cout<<"查询失败的n："<<NOfSearch_BST_Fail<<endl;
            //dayin
            if(NOfSearch_BST_Fail==0 && NOfSearch_BST_Succes!=0)
            {
                cout<<"BST查找失败的ASL："<<"暂无数据"<<endl;
                cout<<"BST查找成功的ASL："<<NumOfASL_BST / NOfSearch_BST_Succes<<endl;
            }
            else if(NOfSearch_BST_Succes==0 && NOfSearch_BST_Fail!=0)
            {
                cout<<"BST查找失败的ASL："<<NumOfASL_BST_Fail / NOfSearch_BST_Fail<<endl;
                cout<<"BST查找成功的ASL："<<"暂无数据"<<endl;
            }
            else if(NOfSearch_BST_Succes==0 && NOfSearch_BST_Fail==0)
            {
                cout<<"BST查找失败的ASL："<<"暂无数据"<<endl;
                cout<<"BST查找成功的ASL："<<"暂无数据"<<endl;
            }
            else
            {
                cout<<"BST查找失败的ASL："<<NumOfASL_BST_Fail / NOfSearch_BST_Fail<<endl;
                cout<<"BST查找成功的ASL："<<NumOfASL_BST / NOfSearch_BST_Succes<<endl;
            }
        }
        if(order==6)
        {
            int NumOfStudent1;
            cout<<"请输入学生数"<<endl;
            cin>>NumOfStudent1;
            cout<<"请输入学号和相关成绩 用空格隔开"<<endl;
            TA=CreatA(TA,NumOfStudent1);
        }
        if(order==7)//中序遍历
        {
            cout<<"中序："<<endl;
            midputA(TA);
            cout<<"前序："<<endl;
            firsputA(TA);
        }
        if(order==8)//插入
        {
            cout<<"请输入要插入的学生信息"<<endl;
            cin>>num>>grade;
            TA=insertA(TA,num,grade);
            if(TA!=NULL)
            cout<<"插入成功！"<<endl;
            else
            cout<<"插入失败。。。"<<endl;;
        }
        if(order==9)//删除
        {
            cout<<"请输入要删除的学生学号和成绩"<<endl;
            cin>>num>>grade;
            DeleteA(TA,num,grade);
            //if(DeleteA(TA,num,grade)==1)
                cout<<"删除成功"<<endl;
            //else
                //cout<<"删除失败"<<endl;
        }
        if(order==10)//查询
        {
            NumOfASL_AVL_flag=0;
            cout<<"请输入要查询的学生的学号"<<endl;
            cin>>num;
            //记录查找前的查找长度
            NumOfASL_AVL_Last = NumOfASL_AVL;
            SearchA(TA,num);

            if(NumOfASL_AVL_flag==0)//查找失败
            {
                cout<<"查找失败!"<<endl;
                //计算失败的ASL，
                NumOfASL_AVL_Fail+=NumOfASL_AVL-NumOfASL_AVL_Last;
                NumOfASL_AVL=NumOfASL_AVL_Last;
                NOfSearch_AVL_Fail++;
            }
            else//查找成功
            {
                NOfSearch_AVL_Succes++;
            }
            cout<<"查询成功的总长度："<<NumOfASL_AVL<<endl;
            cout<<"查询失败的总长度："<<NumOfASL_AVL_Fail<<endl;
            cout<<"查询成功的n："<<NOfSearch_AVL_Succes<<endl;
            cout<<"查询失败的n："<<NOfSearch_AVL_Fail<<endl;
            //打印`
            if(NOfSearch_AVL_Fail==0 && NOfSearch_AVL_Succes!=0)
            {
                cout<<"AVL查找失败的ASL："<<"暂无数据"<<endl;
                cout<<"AVL查找成功的ASL："<<NumOfASL_AVL / NOfSearch_AVL_Succes<<endl;
            }
            else if(NOfSearch_AVL_Succes==0 && NOfSearch_AVL_Fail!=0)
            {
                cout<<"AVL查找失败的ASL："<<NumOfASL_AVL_Fail / NOfSearch_AVL_Fail<<endl;
                cout<<"AVL查找成功的ASL："<<"暂无数据"<<endl;
            }
            else if(NOfSearch_AVL_Succes==0 && NOfSearch_AVL_Fail==0)
            {
                cout<<"AVL查找失败的ASL："<<"暂无数据"<<endl;
                cout<<"AVL查找成功的ASL："<<"暂无数据"<<endl;
            }
            else
            {
                cout<<"AVL查找失败的ASL："<<NumOfASL_AVL_Fail / NOfSearch_AVL_Fail<<endl;
                cout<<"AVL查找成功的ASL："<<NumOfASL_AVL / NOfSearch_AVL_Succes<<endl;
            }
        }
        if(order==0)
        {
            cout<<"*                                          *"<<endl;
            cout<<"************** 感谢您的使用 ***************"<<endl;
            break;
        }
    }
    return 0;
}

AVL.cpp

#include "BST.h"
#include <bits/stdc++.h>
using namespace std;
extern double NumOfASL_AVL;
extern int NumOfASL_AVL_flag;
BTNode * CreatA(BTNode *T,int n)//创建
{
    char nums[6];
    int i,grades;
    for(i=0; i<n; i++)
    {
        cin>>nums>>grades;
        //cout<<"验证1:"<<nums<<grades<<" ";
        T=insertA(T,nums,grades);
    }
    return T;
}  //
BTNode* insertA(BTNode* node,char *num, int key)
{

    if (node == NULL)
        return newNode(num,key);

    if (key < node->data.grade)
        node->left = insertA(node->left,num ,key);
    else if (key > node->data.grade)
        node->right = insertA(node->right,num, key);
    else
        return node;

    node->height = 1 + max(height(node->left), height(node->right));


    int balance = getBalance(node);



    if (balance > 1 && key < node->left->data.grade) //LL型
        return ll_rotate(node);


    if (balance < -1 && key > node->right->data.grade)     //RR型
        return rr_rotate(node);


    if (balance > 1 && key > node->left->data.grade)     //LR型
    {
        node->left = rr_rotate(node->left);
        return ll_rotate(node);
    }

    if (balance < -1 && key < node->right->data.grade)     //RL型
    {
        node->right = ll_rotate(node->right);
        return rr_rotate(node);
    }

    return node;
}
void midputA(BTNode *T)
{
    if(T)
    {
        midputA(T->left);
        cout<<"学号: "<<T->data.num<<" "<<"成绩:"<<T->data.grade<<endl;
        midputA(T->right);
    }
}
void firsputA(BTNode *T)
{
    if(T)
    {
        cout<<"学号: "<<T->data.num<<" "<<"成绩:"<<T->data.grade<<endl;
        firsputA(T->left);
        firsputA(T->right);
    }
}
int height(struct Node *N)
{
    if (N == NULL)
        return 0;
    return N->height;
}

int max(int a, int b)
{
    return (a > b) ? a : b;
}
int getBalance(BTNode* N)
{
    if (N == NULL)
        return 0;
    return height(N->left) - height(N->right);
}
BTNode* ll_rotate(BTNode* y)
{
    BTNode *x = y->left;
    y->left = x->right;
    x->right = y;

    y->height = max(height(y->left), height(y->right)) + 1;
    x->height = max(height(x->left), height(x->right)) + 1;

    return x;
}

BTNode* rr_rotate(BTNode* y)
{
    BTNode *x = y->right;
    y->right = x->left;
    x->left = y;

    y->height = max(height(y->left), height(y->right)) + 1;
    x->height = max(height(x->left), height(x->right)) + 1;

    return x;
}
BTNode* DeleteA(BTNode* root,char *num, int key)
{

    if (root == NULL)
        return root;

    if (key < root->data.grade)
        root->left = DeleteA(root->left,num, key);

    else if (key > root->data.grade)
        root->right = DeleteA(root->right,num, key);

    else
    {
        if ((root->left == NULL) || (root->right == NULL))
        {
            BTNode* temp = root->left ? root->left : root->right;

            if (temp == NULL)
            {
                temp = root;
                root = NULL;
            }
            else
                *root = *temp;
            free(temp);
        }
        else
        {
            BTNode* temp = minValueNode(root->right);

            root->data.grade = temp->data.grade;
            int b;
            for(b=0;b<6;b++)
            {
                root->data.num[b] = temp->data.num[b];
            }

            root->right = DeleteA(root->right, temp->data.num,temp->data.grade);
        }
    }


    if (root == NULL)
        return root;

    root->height = 1 + max(height(root->left), height(root->right));

    int balance = getBalance(root);


    if (balance > 1 && getBalance(root->left) >= 0) //LL型
        return ll_rotate(root);


    if (balance > 1 && getBalance(root->left) < 0) //LR型
    {
        root->left = rr_rotate(root->left);
        return ll_rotate(root);
    }

    if (balance < -1 && getBalance(root->right) <= 0) //RR型
        return rr_rotate(root);

    if (balance < -1 && getBalance(root->right) > 0)  //Rl型
    {
        root->right = ll_rotate(root->right);
        return rr_rotate(root);
    }

    return root;
}
/*void SearchA(BTNode *T,char num[]) //查找
{
    if(T!=NULL)
    {
        NumOfASL_AVL++;
        SearchA(T->left,num);
        if(strcmp(num,T->data.num)==0)
        {
            cout<<"查找成功"<<endl;
            cout<<"学号: "<<T->data.num<<" "<<"成绩:"<<T->data.grade<<endl;
            NumOfASL_AVL_flag++;
            return;
        }
        SearchA(T->right,num);
    }
}*/
void SearchA(BTNode *T,char num[])
{
    NumOfASL_AVL++;
	if (T==NULL)  //没找到元素
	{
		return ;
	}
	else if(strcmp(num,T->data.num)<0)
	{
        SearchA(T->left,num); //在左子树里面查找
	}
	else if(strcmp(num,T->data.num)>0)
	{
		SearchA(T->right,num); //在右子树里面查找
	}
	else //相等
    {
        cout<<"查找成功!"<<endl;
        cout<<"学号: "<<T->data.num<<" "<<"成绩:"<<T->data.grade<<endl;
        NumOfASL_AVL_flag++;
        return ;
    }
}
BTNode* newNode(char *num,int key)
{
    struct Node* node = (BTNode*)malloc(sizeof(struct Node));
    node->data.grade= key;
    int c;
    for(c=0;c<6;c++)
    {
        node->data.num[c]= num[c];
    }
    node->left = NULL;
    node->right = NULL;
    node->height = 1;
    return(node);
}
BTNode * minValueNode(BTNode* node)
{
    BTNode* current = node;

    while (current->left != NULL)
        current = current->left;

    return current;
}

BST.cpp

#include <bits/stdc++.h>
#include "BST.h"
using namespace std;
extern double NumOfASL_BST;
extern int NumOfASL_BST_flag;
BTree Insert(BTree T,char *nums,int grades) //插入
{
    int i;
    if(!T)//T结点为空
    {
        T=new BNode;
        T->lchild=NULL;
        T->rchild=NULL;
        for(i=0; i<6; i++)
        {
            T->data.num[i]=nums[i];
        }
        T->data.grade=grades;
        //cout<<"学号: "<<T->data.num<<" "<<"成绩:"<<T->data.grade<<endl;
        return T;
    }
    else//非空
    {
        //  cout<<"*********";
        if(grades>=T->data.grade)//大的放在右
            T->rchild=Insert(T->rchild,nums,grades);
        else if(grades<T->data.grade)//小的放左
            T->lchild=Insert(T->lchild,nums,grades);
        return T;
    }
}
BTree Creat(BTree T,int n)//创建
{
    char nums[6];
    int i,grades;
    for(i=0; i<n; i++)
    {
        cin>>nums>>grades;
        //cout<<"验证1:"<<nums<<grades<<" ";
        T=Insert(T,nums,grades);
    }
    return T;
}  //
void midput(BTree T)
{
    if(T)
    {
        midput(T->lchild);
        cout<<"学号: "<<T->data.num<<" "<<"成绩:"<<T->data.grade<<endl;
        midput(T->rchild);
    }
}
void firstput(BTree T)
{
    if(T)
    {
        cout<<"学号: "<<T->data.num<<" "<<"成绩:"<<T->data.grade<<endl;
        firstput(T->lchild);
        firstput(T->rchild);
    }
}
void Search(BTree T,char num[])
{
    NumOfASL_BST++;
	if (T==NULL)  //没找到元素
	{
		return ;
	}
	else if(strcmp(num,T->data.num)<0)
	{
        Search(T->lchild,num); //在左子树里面查找
	}
	else if(strcmp(num,T->data.num)>0)
	{
		Search(T->rchild,num); //在右子树里面查找
	}
	else //相等
    {
        cout<<"查找成功!"<<endl;
        cout<<"学号: "<<T->data.num<<" "<<"成绩:"<<T->data.grade<<endl;
        NumOfASL_BST_flag++;
        return ;
    }
}
void save(BTree T,char num[][20],int grade[])
{
    static int x=0;
    if(T)
    {
        strcpy(num[x],T->data.num);
        grade[x]=T->data.grade;
        x++;
        save(T->lchild,num,grade);
        save(T->rchild,num,grade);
    }
}
int Delete(BTree T,char *num,int key)
{
    BTree p,f,q,s;
    p=T;//p为要删除的节点
    f=NULL;//f为p的父节点
    while(p)//找到key的位置（即p的位置）
    {
        if(strcmp(num,p->data.num)==0)
            break;
        f=p;
        if(key<p->data.grade)
            p=p->lchild;
        else if(key>p->data.grade)
            p=p->rchild;
    }
    if(p==NULL) return 0;//判断空树

    if(p->lchild==NULL)
    {
        if(f==NULL)
            p=p->rchild;
        else if(f->lchild==p)
            f->lchild=p->rchild;
        else if(f->rchild==p)
            f->rchild=p->rchild;
        free(p);
    }
    else
    {
        q=p;
        s=p->lchild;
        while(s->rchild)
        {
            q=p;
            s=s->rchild;
        }
        if(q==p)
            p->lchild=s->lchild;//如果p的左孩子没有右孩子，则直接把p的左孩子往上移
        else q->rchild=s->lchild;
        strcpy(p->data.num,s->data.num);
        p->data.grade=s->data.grade;
        free(s);
    }
    return 1;
}
void book()
{
    cout<<"**************欢迎使用本系统 ***************"<<endl;
    cout<<"* 二叉排序树操作：                         *"<<endl;
    cout<<"*        1.建立二叉排序树                  *"<<endl;
    cout<<"*        2.中序/前序遍历                   *"<<endl;
    cout<<"*        3.向二叉树插入一条学生记录        *"<<endl;
    cout<<"*        4.从二叉树中删除一条学生记录      *"<<endl;
    cout<<"*        5.从二叉树中查询一条学生记录      *"<<endl;
    cout<<"*                                          *"<<endl;
    cout<<"* 二叉平衡树操作：                         *"<<endl;
    cout<<"*        6.建立二叉平衡树                  *"<<endl;
    cout<<"*        7.中序/前序遍历                   *"<<endl;
    cout<<"*        8.向二叉树插入一条学生记录        *"<<endl;
    cout<<"*        9.从二叉树中删除一条学生记录      *"<<endl;
    cout<<"*        10.从二叉树中查询一条学生记录     *"<<endl;
    cout<<"*                                          *"<<endl;
    cout<<"*        0.退出系统                        *"<<endl;
}
猫仍在
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉排序树与平衡二叉树的实现课程设计
11-13
本程序中的数据采用“树形结构”作为其数据结构。具体采用的是“二叉排序树”。 二叉排序树（又称二叉查找树）：(1)若左子树不空，则左子树上所有节点的值均小于它的根结点的值；(2)若右子树不空，则右子树上所有节点均大于它的根结点的值；(3)它的左右子树分别为二叉排序树。
二叉排序树和平衡二叉树
低吟不作语的博客
09-29 2116
概述 对于一组元素 [7, 3, 10, 12, 5, 1, 9] 可以有很多种存储方式，但无论使用哪种数据结构，都或多或少有缺陷。比如使用线性结构存储，排序方便，但查找效率低。二叉排序树的特点就是能在保证元素有序的同时，提高查找的效率。 二叉排序树的定义 二叉排序树，也叫二叉查找树，二叉搜索树，英文名 Binary Sort Tree（BST）。它或者是一颗空树，或者是一颗具有以下性质的二叉树 若左子树不为空，则左子树上所有结点的值均小于它的根结点的值 若右子树不为空，则右子树上所有结点...
二叉排序树、二叉平衡树
QAQ
06-15 149
一、二叉排序树（二叉查找、搜索树） 删除分三种情况： 二、二叉平衡树 还是会满足二叉查找树的性质 所以平衡因子可以为-1、0、1 因此只要调整最小平衡二叉树平衡就能使得整颗树平衡，调整规则等下说 LR和RL麻烦点（分两步旋转）： RL: 小结： 练习： ...
二叉排序树_17281183_刘梦婷_leavingtbk_二叉排序树_
10-01
二叉排序树，又称二叉查找树或二叉搜索树，...二叉排序树的优化版本，如平衡二叉排序树（如AVL树和红黑树），更是广泛应用于数据库索引、文件系统等领域。因此，对二叉排序树的学习和掌握是IT专业人员必备的技能之一。
二叉树的应用：二叉排序树BST和平衡二叉树AVL的构造 课设作业 完整代码
最新发布
02-10
其定义为：二叉排序树或者是空树，或者是满足如下性质的二叉树：1.若它的左子树非空，则左子树上所有结点的值均小于根结点的值；2.若它的右子树非空，则右子树上所有结点的值均大于根结点的值；3.左、右子树本身又各...
实现二叉排序树的各种算法
07-25
实验过程中，学生可能还会探讨不同场景下二叉排序树的表现，比如在已排序和未排序的数据集上构建树的差异，以及在不平衡树和平衡树之间进行操作的效率对比。通过这样的实践，学生能深入理解二叉排序树的原理，并提高...
二叉排序树的实现与基本操作
08-31
二叉排序树（Binary Sort Tree，BST），又称为二叉查找树，是一种特殊的二叉树数据结构，其每个节点都遵循以下三个关键...在实际应用中，通过平衡二叉排序树，如AVL树或红黑树，可以确保树保持相对平衡，从而提高性能。
二叉排序树与平衡二叉树的实现
04-08
题　目 二叉排序树与平衡二叉树的实现 1、课程设计的目的 使学生进一步理解和掌握课堂上所学各种基本抽象数据类型的逻辑结构、存储结构和操作实现算法，以及它们在程序中的使用方法。 使学生掌握软件设计的基本内容...
二叉排序树的创建、删除、插入等操作
12-29
二叉排序树的创建、删除、插入等操作
数据结构课程设计平衡二叉排序树的三种基本功能：查找、插入、删除。
06-12
1. 本程序实现平衡二叉排序树的三种基本功能：查找、插入、删除。 2. 初始平衡二叉树为空树，由用户输入要创建树的结点数，并输入每个结点的权值，以整数形式表示，边输入边排序构成平衡二叉排序树。 3. 对二叉树的插入和删除操作包含查找操作。插入的过程就要查找二叉树中是否存在和将插入结点的权值相等的结点，如果存在则不插入该结点。删除操作中如果指定要删除某个权值的结点，则也要先查找二叉树中是否存在与此权值相等的结点，若无，则删除失败。
09.二叉排序树和平衡二叉树
gudongkun1121的博客
01-21 1781
一、二叉排序树 1.什么是二叉排序树 二叉排序树要么是空二叉树 ，要么具有如下特点： 二叉排序树中，如果其根结点有左子树，那么左子树上所有结点的值都小于根结点的值； 二叉排序树中，如果其根结点有右子树，那么右子树上所有结点的值都大于根结点的值； 二叉排序树的左右子树也要求都是二叉排序树； 如下图就是一个二叉排序树： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VsGloKcV-1642763317481)(C:\Users\86186\AppData\Roaming\T
【数据结构】二叉排序树与平衡二叉树
WINGREZ‘S BLOG
09-13 1879
参考资料：《数据结构（C语言版）严蔚敏著》 版权说明：未经作者允许，禁止转载。如引用本文内容，需标明作者及出处。如本文侵犯了您的权益，请联系我删除并致歉。 文章说明：如文章中出现错误，请联系我更改。如您对文章的内容有任何疑问，也欢迎来与我讨论。 本文正在施工中...请稍等... 二叉排序树与平衡二叉树 二叉排序树 二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： (1) 若它的左子树不...
数据结构（一）：二叉排序树和平衡二叉树
goodgoodstudy___的博客
04-09 5476
自平衡二叉树
数据结构之《二叉排序树和平衡二叉树》实现
weixin_44184990的博客
09-21 1626
二叉排序树及平衡二叉树 二叉排序树 定义： 二叉排序树或是一棵空树，或者是一棵满足以下条件的二叉树： 如果二叉排序的左子树非空，则其左子树所有顶点的值均小于该二叉排序树的根节点；其左子树也是一颗二叉排序树。 如果二叉排序的右子树非空，则其右子树的所有顶点的值均大于该二叉排序树的根节点；其右子树也是一颗二叉排序树。 如图所示： 由上图可以发现，图b中的6比根节点5要大，不满足二叉排序树的条件，因此不是一颗二叉排序树。   二叉排序树可以用于查找算法的优化中，除去哈希表等之外，其他

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值