数据结构-四-二叉查找树

最新推荐文章于 2021-12-13 14:00:17 发布
最新推荐文章于 2021-12-13 14:00:17 发布
阅读量120 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42482815/article/details/119656026
版权

title: 数据结构 四 二叉查找树
tags: [数据结构,树]
categories:

  • 数据结构
  • 树
    date: 2021-07-03 14:50:33

二叉查找树

二叉查找树是一个有序的树，使用二叉查找树可以极大的方便查找排好序的元素

二叉查找树保证其中每一个结点的右子树都比他大，左子树都比他小，即左小右大。设x为二叉查找树中的一个结点，x节点包含关键字key，节点x的key值记为key[x]。如果y是x的左子树中的一个结点，则key[y] <= key[x]；如果y是x的右子树的一个结点，则key[y] >= key[x]。

前驱

在中序遍历中排在某元素前面的那个元素是该元素的前驱，当然第一个元素是没有前驱的。在数组型的二叉树中，前驱就放在其前面。
寻找前驱的算法如下：
1. 若一个结点有左子树，则左子树的最右侧即为所求前驱。（也就是左边的最大值）
2. 若没有左子树，则从这个结点向上遍历，直到找到某个结点是其父节点的右子树，则这个结点的父节点即为所求。所不存在则说明没有前驱。

后继

在中序遍历中排在某元素后面的那个元素是该元素的后继，当然最后一个元素是没有后继的。在数组型的二叉树中，后继就放在其后面。
寻找后继的算法如下：
1. 若一个结点有右子树，则右子树的最左侧即为所求前驱。（也就是右边的最小值）
2. 若没有右子树，则从这个结点向上遍历，直到找到某个结点是其父节点的左子树，则这个结点的父节点即为所求。所不存在则说明没有后继。

ADT

  1. 构造空树
  2. 销毁一个树
  3. 判断树是否为空
  4. 插入一个结点
  5. 删除一个结点
  6. 打印二叉树
  7. 前序遍历
  8. 中序遍历
  9. 后序遍历
  10. 根据值的大小查找结点。
  11. 查找子树的最小结点
  12. 查找子树的最大结点
  13. 查找某个结点的前驱
  14. 查找某个结点的后继

二叉查找树的实现

接口说明

//二叉查找树
// binary search tree

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#include <time.h>

typedef struct BSTree
{
    int key; //可以用Item代替，不过为了方便学习，就不这样了。
    struct BSTree *parent;
    struct BSTree *left;
    struct BSTree *right;
} * BSTree;

//初始化
bool InitBSTree(BSTree *tree);

//销毁
bool DestroyBSTree(BSTree *tree);

//空
bool EmptyBSTree(BSTree *tree);

//插入
bool InsertBSTree(BSTree *tree, int key);

//删除
bool DeleteBSTree(BSTree *tree, int key);

//打印二叉树 0代表根节点 1代表左边 -1代表右
void Print_BSTree(BSTree *tree, int direction);

// 前序遍历
void Preorder_BSTree(BSTree *tree);
// 中序遍历
void Inorder_BSTree(BSTree *tree);
// 后序遍历
void Postorder_BSTree(BSTree *tree);

// (递归实现)查找"二叉树x"中键值为key的节点
bool Search_BSTree(BSTree *tree, int key, BSTree *tree_save);
// (非递归实现)查找"二叉树x"中键值为key的节点
bool iterative_bstree_search(BSTree *tree, int key, BSTree *tree_save);

// 查找最小结点：返回tree为根结点的二叉树的最小结点。
bool Min_BSTree(BSTree *tree, BSTree *tree_save);
// 查找最大结点：返回tree为根结点的二叉树的最大结点。
bool Max_BSTree(BSTree *tree, BSTree *tree_save);

// 找结点(x)的后继结点。即，查找"二叉树中数据值大于该结点"的"最小结点"。
bool Sucessor_BSTree(BSTree *tree, BSTree *x, BSTree *sucessor);
// 找结点(x)的前驱结点。即，查找"二叉树中数据值小于该结点"的"最大结点"。
bool Predecessor_BSTree(BSTree *tree, BSTree *x, BSTree *prede);

void AutoFillBSTree(BSTree *tree, int size);

接口实现

#include "bstree.h"

//初始化
bool InitBSTree(BSTree *tree)
{
    (*tree) = NULL;
    printf("初始化成功\n");
}

//销毁
bool DestroyBSTree(BSTree *tree)
{
    if ((*tree) != NULL)
    {
        if ((*tree)->left == NULL && (*tree)->right == NULL)
        {
            free(tree);
            return true;
        }
        DestroyBSTree(&((*tree)->left));
        DestroyBSTree(&((*tree)->right));
        if ((*tree) == NULL)
        {
            printf("销毁成功\n");
            return true;
        }
        else
        {
            printf("销毁失败\n");
            return false;
        }
    }
    if ((*tree) == NULL)
    {
        printf("销毁成功\n");
        return true;
    }
}

//空
bool EmptyBSTree(BSTree *tree)
{
    if ((*tree) == NULL)
    {
        printf("空\n");
        return true;
    }
    else
    {
        printf("不空\n");
        return false;
    }
}

//插入
bool InsertBSTree(BSTree *tree, int key)
{
    BSTree new = (BSTree)malloc(sizeof(struct BSTree));
    new->key = key;
    new->left = NULL;
    new->right = NULL;
    new->parent = NULL;
    //左低右高
    if (EmptyBSTree(tree))
    {
        (*tree) = new;
        printf("插入成功 %d\n", key);
        return true;
    }
    else
    {
        //寻找位置进行插入；
        BSTree p = (*tree);
        while (p != NULL)
        {
            //小 往左走
            if (new->key < p->key)
            {
                if (p->left == NULL)
                {
                    //左边为空，则插入到左边即可
                    p->left = new;
                    new->parent = p;
                    printf("插入成功 %d 到 %d 的左边\n", key, p->key);
                    return true;
                }
                else
                {
                    //左边不空，继续寻找
                    p = p->left;
                }
            }
            //大 往右走
            else if (new->key > p->key)
            {
                if (p->right == NULL)
                {
                    //右边为空，则插入到右边即可
                    p->right = new;
                    new->parent = p;
                    printf("插入成功 %d 到 %d 的右边\n", key, p->key);
                    return true;
                }
                else
                {
                    //右边不空，继续寻找
                    p = p->right;
                }
            }
            else if (new->key == p->key)
            {
                printf("不允许相等的元素存在,插入失败\n");
                return false;
            }
        }
    }
    printf("插入失败\n");
    return false;
}

//删除
bool DeleteBSTree(BSTree *tree, int key)
{
    //删除的是根节点 删除叶子节点 删除的结点没有左子树或者右子树
    //空
    if (EmptyBSTree(tree))
    {
        printf("删除失败\n");
        return false;
    }
    BSTree p = (*tree);
    //p指向树的每一个结点（其实就是相应内存区域），改变 p->key，就是改变这块内存上key的值。所以才可以实现使用p遍历并更改结点。
    //其实，p->key==(*p).key  对(*p).key很自然就修改了其值，这点很容易理解。
    //假设这棵树在一个树的左边  解决删除的是根节点的问题
    BSTree fakeroot = (BSTree)malloc(sizeof(struct BSTree));
    fakeroot->left = p;
    fakeroot->right = NULL;
    fakeroot->parent = NULL;
    p->parent = fakeroot;
    if (p->key == (*p).key)
        printf("true\n");
    while (p != NULL)
    {
        //printf("1111111111111111111111\n");
        if (p->key < key)
        {
            //向右走
            //printf("向右走\n");
            p = p->right;
        }
        else if (p->key > key)
        {
            p = p->left;
            //printf("向左走\n");
        }
        else if (p->key == key)
        {
            //找到了，进行删除 p
            printf("找到了，进行删除 p %d\n", p->key);
            BSTree l = p->left;
            BSTree r = p->right;
            //p为左子树
            if (p->parent->left == p)
            {
                //p没有左子树
                if ((l == NULL) && (r != NULL))
                {
                    p->parent->left = r;
                    r->parent = p->parent;
                    free(p);
                    p = NULL;
                    (*tree) = fakeroot->left;
                    printf("删除成功\n");
                    return true;
                }
                //p没有右子树
                else if ((r == NULL) && (l != NULL))
                {
                    p->parent->left = l;
                    l->parent = p->parent;
                    free(p);
                    p = NULL;
                    (*tree) = fakeroot->left;
                    printf("删除成功\n");
                    return true;
                }
                //p左右子树都有
                else if ((r != NULL) && (l != NULL))
                {
                    //p为左节点，应为右侧的高 继位
                    p->parent->left = r;
                    //将l插入到r的最左下
                    while (r->left != NULL)
                    {
                        r = r->left;
                    }
                    //找到了右子树的最左边，插入左子树
                    r->left = l;
                    l->parent = r;
                    free(p);
                    p = NULL;
                    (*tree) = fakeroot->left;
                    printf("删除成功\n");
                    return true;
                }
                //左右子树都没有
                else
                {
                    p->parent->left = NULL;
                    free(p);
                    p = NULL;
                    (*tree) = fakeroot->left;
                    printf("删除成功\n");
                    return true;
                }
            }
            //p为右子树
            else
            {
                //将 右子树顶替p的位置，然后将左子树插入到右子树的最左下面即可，因为右边比左边大。
                //p为右节点，应为左侧的低 继位
                //p没有左子树
                if ((l == NULL) && (r != NULL))
                {
                    p->parent->right = r;
                    r->parent = p->parent;
                    free(p);
                    p = NULL;
                    (*tree) = fakeroot->left;
                    printf("删除成功\n");
                    return true;
                }
                //p没有右子树
                else if ((r == NULL) && (l != NULL))
                {
                    p->parent->right = l;
                    l->parent = p->parent;
                    free(p);
                    p = NULL;
                    (*tree) = fakeroot->left;
                    printf("删除成功\n");
                    return true;
                }
                //p左右子树都有
                else if ((r != NULL) && (l != NULL))
                {
                    p->parent->right = l;
                    while (l->right != NULL)
                    {
                        l = l->right;
                    }
                    //找到了右子树的最左边，插入左子树
                    l->right = r;
                    r->parent = l;
                    free(p);
                    p = NULL;
                    (*tree) = fakeroot->left;
                    printf("删除成功\n");
                    return true;
                }
                //左右子树都没有
                else
                {
                    p->parent->right = NULL;
                    free(p);
                    p = NULL;
                    (*tree) = fakeroot->left;
                    printf("删除成功\n");
                    return true;
                }
            }
        }
    }
    printf("没有找到这个元素，删除失败\n");
    return true;
}

//打印二叉树 0代表根节点 -1代表左边 1代表右
void Print_BSTree(BSTree *tree, int direction)
{
    BSTree p = *tree;
    if (p != NULL)
    {
        //根节点
        if (direction == 0)
        {
            printf("结点 %2d 为根节点\n", p->key);
        }
        //左
        else if (direction == -1)
        {
            printf("结点 %2d 为结点 %2d 的left\n", p->key, p->parent->key);
        }
        else
        {
            printf("结点 %2d 为结点 %2d right\n", p->key, p->parent->key);
        }
        Print_BSTree(&(p->left), -1);
        Print_BSTree(&(p->right), 1);
    }
}

// 前序遍历
void Preorder_BSTree(BSTree *tree)
{
    BSTree p = (*tree);
    if (p == NULL)
    {
        return;
    }
    else
    {
        printf("%d ", p->key);
        Preorder_BSTree(&(p->left));
        Preorder_BSTree(&(p->right));
    }
}
// 中序遍历
void Inorder_BSTree(BSTree *tree)
{
    BSTree p = (*tree);
    if (p == NULL)
    {
        return;
    }
    else
    {
        Inorder_BSTree(&(p->left));
        printf("%d ", p->key);
        Inorder_BSTree(&(p->right));
    }
}
// 后序遍历
void Postorder_BSTree(BSTree *tree)
{
    BSTree p = (*tree);
    if (p == NULL)
    {
        return;
    }
    else
    {
        Postorder_BSTree(&(p->left));
        Postorder_BSTree(&(p->right));
        printf("%d ", p->key);
    }
}

// (递归实现)查找"二叉树x"中键值为key的节点
bool Search_BSTree(BSTree *tree, int key, BSTree *tree_save)
{
    BSTree p = (*tree);
    if (p == NULL)
    {
        //*tree_save = NULL;
        //printf("没找到\n");
        return false;
    }
    if (p->key == key)
    {
        //找到了
        *tree_save = p;
        printf("找到了\n");
        return true;
    }
    Search_BSTree(&(p->left), key, tree_save);
    Search_BSTree(&(p->right), key, tree_save);
}
// (非递归实现)查找"二叉树x"中键值为key的节点
bool iterative_bstree_search(BSTree *tree, int key, BSTree *tree_save)
{
    BSTree p = (*tree);
    while (p != NULL)
    {
        if (p->key == key)
        {
            //找到了
            (*tree_save) = p;
            printf("找到了\n");
            return true;
        }
        else if (p->key < key)
        {
            //往右走
            p = p->right;
        }
        else if (p->key > key)
        {
            p = p->left;
        }
    }
    //没找到
    (*tree_save) = NULL;
    printf("没找到\n");
    return false;
}

// 查找最小结点：返回tree为根结点的二叉树的最小结点。
bool Min_BSTree(BSTree *tree, BSTree *tree_save)
{
    BSTree p = (*tree);
    if (p == NULL)
    {
        *tree_save = NULL;
        return false;
    }
    while (p->left != NULL)
    {
        p = p->left;
    }
    *tree_save = p;
    return true;
}
// 查找最大结点：返回tree为根结点的二叉树的最大结点。
bool Max_BSTree(BSTree *tree, BSTree *tree_save)
{
    BSTree p = (*tree);
    if (p == NULL)
    {
        *tree_save = NULL;
        return false;
    }
    while (p->right != NULL)
    {
        p = p->right;
    }
    *tree_save = p;
    return true;
}

//前驱节点：对一棵二叉树进行中序遍历，遍历后的顺序，当前节点的前一个节点为该节点的前驱节点；

//后继节点：对一棵二叉树进行中序遍历，遍历后的顺序，当前节点的后一个节点为该节点的后继节点；

// 找结点(x)的后继结点。即，查找"二叉树中数据值大于该结点"的"最小结点"。
bool Sucessor_BSTree(BSTree *tree, BSTree *x, BSTree *sucessor)
{
    //即其右子树的最左边
    if ((*x) == NULL)
    {
        printf("空结点，没有后继\n");
        (*sucessor) = NULL;
        return false;
    }
    //有右子树
    else if ((*x)->right != NULL)
    {
        Min_BSTree(&((*x)->right), sucessor);
        printf("找到了后继，%d 的后继为 %d \n", (*x)->key, (*sucessor)->key);
        return true;
    }
    //没有右子树 则从此开始向上找一个是左结点的结点
    else if ((*x)->right == NULL)
    {
        BSTree p = *x;
        //从x往上查，直到有一个结点是左节点  则该左节点的父节点为所求
        while (p->parent != NULL)
        {
            if (p->parent->left == p)
            {
                *sucessor = p->parent;
                printf("找到了后继，%d 的后继为 %d \n", (*x)->key, (*sucessor)->key);
                return true;
            }
            else
            {
                p = p->parent;
            }
        }
        //p此时已经是root了，还没有找到说明那个结点没有后继。
        printf("结点 %d 没有后继\n", (*x)->key);
        (*sucessor) = NULL;
        return false;
    }
}
// 找结点(x)的前驱结点。即，查找"二叉树中数据值小于该结点"的"最大结点"。
bool Predecessor_BSTree(BSTree *tree, BSTree *x, BSTree *prede)
{
    if (*x == NULL)
    {
        printf("空结点，没有前驱\n");
        *prede = NULL;
        return false;
    }
    //左子树 则寻找其左子树的最大值
    if ((*x)->left != NULL)
    {
        Max_BSTree(&((*x)->left), prede);
        printf("找到了前驱，%d 的前驱为 %d \n", (*x)->key, (*prede)->key);
        return true;
    }
    //没有左子树，则向上寻找一个是其父节点的右子树的结点。
    else if ((*x)->left == NULL)
    {
        BSTree p = *x;
        while (p->parent != NULL)
        {
            if (p->parent->right == p)
            {
                *prede = p->parent;
                printf("找到了前驱，%d 的前驱为 %d \n", (*x)->key, (*prede)->key);
                return true;
            }
            else
            {
                p = p->parent;
            }
        }
        //p此时已经是root了，还没有找到说明那个结点没有前驱。
        printf("结点 %d 没有前驱\n", (*x)->key);
        (*prede) = NULL;
        return false;
    }
}

void AutoFillBSTree(BSTree *tree, int size)
{
    InsertBSTree(tree, 5);
    InsertBSTree(tree, 4);
    InsertBSTree(tree, 6);
    InsertBSTree(tree, 2);
    InsertBSTree(tree, 3);
    InsertBSTree(tree, 1);
    InsertBSTree(tree, 8);
    InsertBSTree(tree, 7);
    InsertBSTree(tree, 9);

    for (int i = 1; i <= 10; i++)
    {
        BSTree sucessor = NULL;
        BSTree x = NULL;
        Search_BSTree(tree, i, &x);
        Sucessor_BSTree(tree, &x, &sucessor);
        if (sucessor != NULL)
            printf("succor: %d\n", sucessor->key);
    }
    for (int i = 1; i <= 10; i++)
    {
        BSTree prede = NULL;
        BSTree x = NULL;
        Search_BSTree(tree, i, &x);
        Predecessor_BSTree(tree, &x, &prede);
        if (prede != NULL)
            printf("succor: %d\n", prede->key);
    }
}

接口使用

#include "bstree.c"

int main()
{
    BSTree tree;
    InitBSTree(&tree);
    //DestroyBSTree(&tree);
    AutoFillBSTree(&tree, 10);
    printf("\n前序遍历: ");
    Preorder_BSTree(&tree);
    printf("\n中序遍历: ");
    Inorder_BSTree(&tree);
    printf("\n后序遍历: ");
    Postorder_BSTree(&tree);
    printf("\n");
    Print_BSTree(&tree, 0);
}
易水凌波
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构实验-二叉排序树算法
10-26
一、问题描述 根据给定的关键字序列，实现二叉排序树的基本操作。 输入格式：8, 10, 5, 6, 3, 13 二、实验目的 ...1、构造二叉排序树的存储结构。 2、实现创建、查找、插入、删除、平均查找长度等操作。
数据结构进阶(四)二叉排序树(二叉查找树)
热门推荐
IT全栈 华强工作室
09-12 4万+
二叉排序树(二叉查找树)--查找 注:构造一棵二叉排序树的目的，其实并不是为了排序(中序遍历)，而是为了提高查找、插入、删除关键字的速度。定义 二叉排序树又叫二叉查找树，英文名称是：Binary Sort Tree.BST的定义就不详细说了，我用一句话概括：左 二叉查找树是满足以下条件的二叉树： 1.左子树上的所有节点值均小于根节点值； 2.右子树上的所有节点值均不...
动态规划--4.最优二叉查找树
林竹清_清清清
03-15 5667
1.最优二叉查找树 （1）左孩子 （2）树内关键字k1...kn（中间节点k1 d0,d1,dn ；d0表示小于k1的所有值， dn表示大于kn的所有值，它们对应的搜索概率是 q0,q1...qn  如图 （3）每棵树每个节点的期望是 （搜索深度+1）*概率，为什么搜索深度+1不是搜索深度？如果只是搜索深度*概率的话，那么根节点期望岂不是0*概率=0了。 此外每次搜索都有成功和不成功两
二叉树系列---求包含n个节点的二叉查找树的种类数
bh_xiaoxinba的博客
11-05 5673
题目求包含n个节点的二叉树的种类数；方法1设dp[i]表示共有i个节点时，能产生的BST树的个数 n == 0 时，空树的个数必然为1，因此dp[0] = 1 n == 1 时，只有1这个根节点，数量也为1，因此dp[1] = 1 当根节点元素为 1, 2, 3, 4, 5, …, i, …, n时，基于以下原则的BST树具有唯一性：
数据结构与算法分析：（十五） 二叉查找树
riemann_的博客
04-16 555
上一篇我们学了树、二叉树以及二叉树的遍历。请戳：数据结构与算法分析：（十四） 二叉树 二叉树的种类各种各样，这一篇我们主要来讲二叉查找树。二叉查找树最大的特点就是，支持动态数据集合的快速插入、删除、查找操作。 一、二叉查找树（Binary Search Tree） 二叉树的一个重要应用是它们在查找中的使用，它不仅仅支持快速查找一个数据，还支持快速插入、删除一个数据。这里提一个小问题：我们之前讲过散...
数据结构树4-二叉搜索树2
weixin_38383877的博客
05-23 148
二叉搜索树.h: #ifndef _二叉查找树_H #define _二叉查找树_H #include<iostream> #include<string> enum Boolean{ FALSE,TRUE}; template<class Type> class Element { public: Type key; //方便添加更新数据 }; ...
数据结构实验--基于二叉排序树的商品查询系统
10-16
查找是数据处理的重要操作。请设计并实现基于二叉排序树的商品信息查询算法。完成信息的查询、插入、删除、查询频度的统计等功能。
数据结构-用户登录实验-二叉查找树AVL树实现
05-23
该资源实现了数据结构的二叉查找树、AVL树旋转用于用户信息存储，并附有详细的实验报告说明
C++数据结构-二叉查找树和平衡二叉树
01-03
实现了二叉查找树的查找、插入、删除和迭代遍历功能； 实现了平衡二叉树（AVL树）的查找、插入、删除和迭代遍历的完整功能，插入时的各种旋转操作按照经典数据结构教材实现，并有详细的注释和说明。删除操作和相关...
数据结构-红黑树.zip
最新发布
03-21
红黑树（Red Black Tree）是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。这种数据结构由Rudolf Bayer在1972年首次提出，当时被称为平衡二叉B树（Symmetric Binary B-...
算法导论-12-1-具有相同关键字元素的二叉查找树
幸福在路上
07-05 7332
题目： 相同关键字的存在，给二叉查找树的实现带来了一些问题。 a）当用TREE-INSERT将n个具有相同关键字的数据项插入到一棵初始为空的二叉查找树中时，该算法的渐近性能如何？ 我们可以对TREE-INSERT做一些改进，即在第5行的前面测试key[z] = key[x]，在第11行的前面测试key[z] = key[y]。如果等式成立，我们对下列策略中的某一种加以实现。对每一种策略，请给
二叉搜索树的初始化、插入、删除、查找、销毁等操作
Calm的博客
09-15 2260
二叉搜索树的概念 二叉搜索树又称二叉排序树，它或者是一颗空树，或者是具有以下性质的二叉树： 若它的左子树不为空，则左子树上所有结点的值都小于根结点的值 若它的右子树不为空，则右子树上所有结点的值都大于根结点的值 它的左右子树也分别为二叉搜索树 例： 我们要实现这些操作。先定义一个二叉搜索树的结构体，这个结构体成员包括左右孩子两个指针，还有它的数据： typedef int B...
《算法导论》之最优二叉搜索树
sunshine_lyn的博客
09-20 1万+
最优二叉搜索树 假定我们正在设计一个程序，实现英语文本到法语的翻译。对英语文本中出现的每个单词，我们需要查找对应的法语单词。为了实现这些查找操作，可以创建一棵二叉搜索树，将n个英语单词作为关键字，对应的法语单词作为关联数据。由于文本中的每个单词都要进行搜索，我们希望花费在搜索上的总时间尽量少。 通过红黑树或其他平衡搜索树结构，我们可以假定每次搜索时间为O(lgn) 。但由于单词出现的频率是不同的，...
数据结构4-1：二叉搜索树
girls的博客
12-13 241
二叉搜索树什么是二叉搜索树？二叉搜索树操作的特别函数：二叉搜索树的查找操作：Find查找最大和最小元素：FindMin、FindMax二叉搜索树的插入：Insert二叉搜索树的删除：Delete 什么是二叉搜索树？ 静态查找就是我们要找的元素是不动的。也就是说在一个集合上主要做的是find操作，而没有delete一个映射的这种操作发生。静态查找我们讲过的一个例子：二分查找就很nice 另外一种查找就是我们要找的这个对象的集合呢本身会动态的发生变化，也就是说经常要发生插入删除，除了查找之外还有插入删除操作发
数据结构4：实现二叉树
weixin_43897127的博客
08-09 178
文章目录前言二叉树的前中后序遍历前序遍历中序遍历后序遍历遍历求节点个数子问题求节点个数遍历求叶子节点个数子问题求叶子节点个数你们要的代码BinaryTree.javaTestDemo.java 前言 二叉树的前中后序遍历 前序遍历 void preOrderTraversal(Node root) { if(root == null) return; System.out.print(root.val+" "); preOrderTraversal(root.
数据结构与算法（四）二叉搜索树
Damon_zqt的博客
04-27 565
概述 有序数组可以利用二分查找法快速的查找特定的值，时间复杂度为O(log2N)，但是插入数据时很慢，时间复杂度为O(N)；链表的插入和删除速度都很快，时间复杂度为O(1)，但是查找特定值很慢，时间复杂度为O(N)。 那么，有没有一种数据结构既能像有序数组那样快速的查找数据，又能像链表那样快速的插入数据呢？ 树就能满足这种要求，不过依然是以算法的复杂度为代价。 在程序中，节点一般用来表示实体，也...
4个节点能够成多少颗二叉搜索树
zyt157376的博客
10-27 8114
这是一道数据结构练习题，答案是14颗。 包含节点{1,2,3,4}的不同二叉搜索树有多少棵？ 由此问题，我们可以拓展开来： n个互不相同的节点，可以构成多少种拓扑互异的二叉搜索树(Binary Search Tree)？ 首先，考虑以下事实： 包含一个节点的二叉搜索树，显然只有一种情况； 包含两个节点的二叉搜索树，可分别以左节点或右节点为根，剩下的右子树或是左子树只有一种情况； 包含3个节点
hnu 数据结构 实验四
zumhui的博客
07-05 784
实验4 二叉树的应用 分别提交两个附件： 1：设计文档（提交PDF格式的文件，文件名要规范，参看规范）。 2：实验源码包。（文件名也要规范，可以参考报告文件的格式） 一、问题分析 要处理的对象：N个不同的非负键值整数数列 要实现的功能：利用这个非负键值整数数列，构造一颗既是CBT也是BST的树，并将这个数以层次遍历的形式在一行中输出。 结果显示：以层次遍历的形式输出这棵树，输出要求每个数字必须由一个空格隔开，且行首和行尾没有多余的空格。 二、算法思想设计 ①　这个实验的首要任务是建立这样一棵既是二叉搜索树，
数据结构-二叉查找树的应用
08-31
- *2* *3* [数据结构-二叉查找树的应用](https://blog.csdn.net/Junds0/article/details/121791335)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值