数据结构之二叉搜索树

最新推荐文章于 2021-04-14 21:30:28 发布
最新推荐文章于 2021-04-14 21:30:28 发布
阅读量347 收藏
点赞数
分类专栏： C语言 数据结构 算法导论 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ooooo12345re/article/details/50767691
版权
C语言 同时被 3 个专栏收录
20 篇文章 1 订阅
订阅专栏
linux
12 篇文章 0 订阅
订阅专栏
数据结构
11 篇文章 0 订阅
订阅专栏

         一颗二叉搜索树是以一颗二叉树组织的，这样一颗可以使用一个链表数据结构来表示，其中每个节点都是一个对象，除了key之外，每个节点还包含属性left、right和p，它们分别指向节点的左孩子、右孩子和双亲。如果某个孩子结点和父节点不存在，则相应属性的值为NULL，根节点是树中唯一一个父指针为NULL的节点。

                                      6

                                    /    \

                                  5      7

                                /   \       \

                              2    5      8

        二叉搜索树。对于任何节点x，其左子树中的关键字最大不超过x.key，其有子树中的关键字最小不低于x.key。大部分的搜索树操作的最坏运行时间与树的高度成正比。

      二叉搜索树中的关键字总是以满足二叉搜索树性质的方式来存储：

              设x二叉搜索树中的一个节点。如果y是x左子树中的一个节点，那么y.key <= x.key。如果y是x右子树中的一个节点，那么y.key >= x.key 。

       接下来我们实现二叉搜索树的创建、销毁（递归、非递归）、遍历（先序、中序、后序）、得到最大最小值、插入和删除。

       首先我们来看二叉搜索树的对于接口的声明和节点类型的定义：

        binaryserach_tree.h：

#ifndef _SERACH_TREE_
#define _SERACH_TREE_

#include "tools.h"
#define N (10)
typedef struct Tree_node{
    int                      data;    //数据区域
    struct Tree_node *left_child ;    //左孩子
    struct Tree_node *right_child;    //右孩子
    struct Tree_node           *p;    //双亲
}Tree_node;

typedef Tree_node *Bin_tree;    //二叉搜索树节点指针

//二叉搜索树的接口

//二叉搜索树的创建和销毁
Bin_tree creat_tree(int a[],int n);    //创建二叉搜索树
void destroy_tree(Bin_tree *root);    //二叉搜索树的销毁
void destroy_tree_nr(Bin_tree *root);    //二叉搜索树的非递归销毁

//二叉搜索树的遍历
void pre_order_print(Bin_tree root);    //先序遍历
void mid_order_print(Bin_tree root);    //中序遍历
void last_order_print(Bin_tree root);    //后序遍历
void pre_order_print_nr(Bin_tree root);    //先序遍历(非递归)
void mid_order_print_nr(Bin_tree root);    //中序遍历(非递归)
void last_order_print_nr(Bin_tree root);    //后序遍历(非递归)
void level_order_print(Bin_tree root);    //层序遍历

//二叉搜索树的查找
Tree_node * Tree_serach(Bin_tree root,int k);    //递归
Tree_node * Tree_serach_nr(Bin_tree root,int k);   //非递归

//得到最大关键字元素和得到最小关键字元素
Tree_node *get_tree_minnum(Bin_tree root);
Tree_node *get_tree_maxnum(Bin_tree root);

//返回节点的后继（右孩子）
Tree_node *tree_successor(Bin_tree root);

//插入和删除
void tree_insert(Bin_tree root,Tree_node *value);
Bin_tree tree_delete(Bin_tree root,Tree_node *value);

#endif

本次的节点类型的声明和以往的声明有一点不同，就是在Tree_node的结构体中加入了双亲节点，使得我们的后序操作变得方便。

     （a）二叉搜索树的创建：首先根结点单独创建，对于剩余节点遍历数组剩下的元素，创建节点，寻找节点的双亲，其创建的代码如下：


Bin_tree creat_tree(int a[],int n)    //创建二叉搜索树
{
    Tree_node *root = NULL;
    Tree_node *p_node = NULL;
    Tree_node *c = NULL;
    Tree_node *pa = NULL;
    int i = 0;
    if(a == NULL || n < 0){
        return NULL;
    }
    root = (Tree_node *)Malloc(sizeof(Tree_node));
    root ->data = a[0];
    root->left_child = NULL;
    root ->right_child = NULL;
    root ->p = NULL;
    for(i = 1; i < n; ++i){
        p_node = (Tree_node *)Malloc(sizeof(Tree_node));
        p_node ->data = a[i];
        p_node ->left_child = NULL;
        p_node ->right_child = NULL;
        c = root;
        while(c){
            pa = c;
            if(c ->data > p_node ->data){
                c = c ->left_child;
            }else{
                c = c ->right_child;
            }            
        }
        if(pa ->data > p_node ->data){
            pa ->left_child = p_node;
        }else{
            pa ->right_child = p_node;
        }
        p_node ->p = pa;
    }
    return root;
}

其中p_node用于创建新的节点，pa 和 c联动进行寻找p_node插入的位置，最终pa为p_node的双亲，然后比较pa数据域的值和p_node数据域的值，并根据大小将p_node插入到pa的左子女或者右子女。

     看完创建过程，接下来我们来看二叉搜索树的销毁。

      （b）二叉搜索树的销毁：本文章给大家介绍两种方式：递归销毁和非递归销毁。递归销毁的方式比较简单，非递归的销毁方式需要借助于队列，队列的实现在之前的二叉树已经详细的说明，今天则不重点说明，下面我们具体来看实现：

static void destroy(Bin_tree root)
{
    if(root){
        destroy(root ->left_child);
        destroy(root ->right_child);
        free(root);
    }
}
void destroy_tree(Bin_tree *root)    //二叉搜索树的销毁
{
    if(root == NULL || *root == NULL){
        return;
    }
    destroy(*root);
    *root = NULL;
}
void destroy_tree_nr(Bin_tree *root)    //二叉搜索树的非递归销毁
{
    Queue *queue = NULL;
    Tree_node *node = NULL;
    if(root == NULL || *root == NULL){
        return ;
    }
    queue = init_queue();
    in(queue,*root);
    *root = NULL;
    while(!is_queue_empty(queue)){
        get_queue_front(queue,(void **)&node);
        out(queue);
        
        if(node ->left_child){
            in(queue,node ->left_child);
        }
        if(node ->right_child){
            in(queue,node->right_child);
        }
        free(node);
    }
    destory_queue(&queue);
}
     创建和销毁都和大家介绍完了，我们通过查看内存是否泄露来判断程序的对错：

 对于非递归销毁的检测：


对于非递归的检测：


（c）二叉搜索树的遍历：对于遍历比较特殊的是，对于二叉搜索树的中序遍历即可得到升序序列，二叉搜索树的遍历和二叉树遍历方式一样，分为：先序、中序、后序、层序。下面我们来看具体的实现（包括递归、非递归）：

//二叉搜索树的遍历
void pre_order_print(Bin_tree root)    //先序遍历
{
    if(root){
        printf("%5d",root ->data);
        pre_order_print(root ->left_child);
        pre_order_print(root ->right_child);
    }
}
void mid_order_print(Bin_tree root)    //中序遍历
{
    if(root){
        mid_order_print(root ->left_child);
        printf("%5d",root ->data);
        mid_order_print(root ->right_child);
    }

}
void last_order_print(Bin_tree root)    //后序遍历
{
    if(root){
        last_order_print(root ->left_child);
        last_order_print(root ->right_child);
        printf("%5d",root ->data);
    }

}
void level_order_print(Bin_tree root)    //层序遍历
{
    Queue *queue = NULL;
    Tree_node *node = NULL;
    if(root == NULL){
        return ;
    }
    queue = init_queue();
    in(queue,root);
    while(!is_queue_empty(queue)){
        get_queue_front(queue,(void **)&node);
        out(queue);
        printf("%5d",node ->data);
        if(node ->left_child){
            in(queue,node ->left_child);
        }
        if(node ->right_child){
            in(queue,node ->right_child);
        }
    }
    destory_queue(&queue);
}
void pre_order_print_nr(Bin_tree root)    //先序遍历非递归
{
    Stack *stack = NULL;
    Tree_node *node = NULL;
    if(root == NULL){
        return;
    }
    stack = init_stack();
    push(stack,root);
    while(!is_stack_empty(stack)){
        get_top(stack,(void**)&node);
        pop(stack);
        printf("%5d",node ->data);
        if(node ->right_child){
            push(stack,node ->right_child);
        }
        if(node ->left_child){
            push(stack,node ->left_child);
        }
    }
    destroy_stack(&stack);
}
void mid_order_print_nr(Bin_tree root)    //中序遍历非递归
{
    Stack * stack = NULL;
    Tree_node *node = NULL;
    if(root == NULL){
       return;
    }
    stack = init_stack();
    node = root;
    while(!is_stack_empty(stack) || node != NULL){
        while(node != NULL){
            push(stack,node);
            node  = node ->left_child;
        }
        get_top(stack,(void **)&node);
        printf("%5d",node ->data);
        pop(stack);
        node = node ->right_child;
    }
    destroy_stack(&stack);
}
void last_order_print_nr(Bin_tree root)    //后序遍历非递归
{
    Stack *stack = NULL;
    Tree_node *node = NULL;
    Tree_node *prev = NULL;
    if(root == NULL){
        return ;
    }
    stack = init_stack();
    node = root;
    push(stack,node);
    while(!is_stack_empty(stack)){
        get_top(stack,(void **)&node);
        if((node ->left_child == NULL && node ->right_child == NULL) 
                     || (prev != NULL && (node ->left_child == prev
                                    ||node ->right_child == prev))){
            printf("%5d",node ->data);
            pop(stack);
            prev = node;
        }else{
            if(node ->right_child){
                push(stack,node ->right_child);
            }
            if(node ->left_child){
                push(stack,node ->left_child);
            }
        }
    }
    destroy_stack(&stack);
}

对于遍历的检测：



(d)二叉搜索树的查找：对于二叉搜索树的查找可以使用两种方式：递归和非递归，对于二叉搜索树的查找的时间复杂度为o（h），h为树的高度，下面是查找的代码：

//二叉搜索树的查找
Tree_node *Tree_serach(Bin_tree root,int k)    //递归
{
    if(root == NULL || root ->data == k){
        return root;
    }
    if(k < root ->data){
        return Tree_serach(root ->left_child,k);
    }else{
        return Tree_serach(root ->right_child,k);
    }
}
Tree_node * Tree_serach_nr(Bin_tree root,int k)  //非递归
{
    Tree_node *node = NULL;
    node = root;
    while(node != NULL && k!= node ->data){
        if(k < root ->data){
            node = node ->left_child;
        }else{
            node = node ->right_child;
        }
    }
    return node;
}
(d)得到最大和最小的值：由于二叉搜索树的性质，我们可以得出，二叉搜索树的最大值位于右子树的最右边的最后一个叶子，最小值位于左子树的最左边的最后一个叶子，其代码如下： 

//得到最大关键字元素和得到最小关键字元素
Tree_node *get_tree_minnum(Bin_tree root)
{
    Tree_node *node = NULL;
    node = root;
    while(node && node ->left_child){
        node = node ->left_child;
    }
    return node;
}
Tree_node *get_tree_maxnum(Bin_tree root)
{
    Tree_node *node = NULL;
    node = root;
    while(node && node ->right_child){
        node = node ->right_child;
    }
    return node;
}
（e）得到前驱、后继节点：给定一颗二叉搜索树中的一个节点，有时候需要按中序遍历的次序查找它的后继，如果所有的关键字互不相同，则一个节点x的后继是大于x.key的最小关键字的节点，其代码的实现如下： 
//返回节点的后继、前驱
Tree_node *tree_successor(Bin_tree r)
{
    //               15
    //             /   \
    //            6     18
    //           / \    / \
    //          3   7  17  20
    //         / \   \
    //        2   4   13
    //                /
    //                9
    //   给定一颗二叉树中的节点，有时则需要按中序遍历的次序查找它的后继
    //   如果所有的关键字都不相同，则一个节点x的后继是大于x.key的最小关键字
    //   的节点
    //   因此可分为两种情况：
    //   第一种：节点x 的右子树非空，那么x的后继恰是x右子树的最左节点
    //   可以通过get_tree_minnum(x.right)的调用找到 例如 关键字为15的节点
    //   的后继是关键字为17的节点  
    //   第二种：如果节点x的右子树为空并有一个后继y，那么y是x的最底层祖先
    //   例如：关键字为13的节点的后继是关键字为15的节点
    Tree_node *parent = NULL;
    Tree_node *node = NULL;
    node = r;
    if(r == NULL){
        return NULL;
    }
    if(r ->right_child){
        return get_tree_minnum(r ->right_child);
    }
    parent = node ->p;
    while(parent && node == parent ->right_child){
        node = parent;
        parent = parent ->p;
    }
    return parent;
}

（f）二叉搜索树的插入：二叉树的插入操作的代码如下：node和parent用于确定新节点插入的位置，parent为新节点的双亲节点，最后再将新节点挂在parent的左子女上或右子女上。 

void tree_insert(Bin_tree root,Tree_node *value)
{
    Tree_node *node = NULL;
    Tree_node *parent = NULL;
    if(value == NULL){
        return;
    }
    node = root;
    while(node){
        parent = node;
        if(node ->data < value ->data){
            node = node ->right_child;
        }else {
            node = node ->left_child;
        }
    }
    value ->p = parent;
    if(parent == NULL){
       root = value; 
    }else{  
        if(value ->data > parent ->data){
            parent ->right_child = value;
        }else{
            parent->left_child = value;
        }
    }
}
（g） 二叉搜索树删除：
       从一颗二叉搜索树T中删除一个节点z的整个策略可以分为三种基本情况（如下所述），但是只有一种情况比较棘手。

       1>如果z没有孩子节点，那么只是简单的删除，并修改它的父节点，用NULL作为孩子来替换z

       2>如果在z只有一个孩子，那么将这个孩子提升到树中的z的位置，并修改z的父节点，用z的孩子来替换z；

       3>如果z有两个孩子，那么找z的后继y（一定在z的右子树中），并让y占据树中z的位置。z的原来的右子树部分成为y的新的右子树，并且z的左子树成为y的新的左子树。这种情况稍显麻烦，因为还与y是否为z的右子树相关。

      从一颗二叉搜索树T中删除一个节点z，这个过程取指向T和z的指针作为输入参数，考虑如图所示的4种情况，它与前面概括出的三种情况有所不同。

        a>

                                      Z

                                   /      \                                           R

                             NULL    R             ------->              /    \

                                         /    \                                                                                                                                                          

                                             (a)

              如图（a）所示 ，z没有左孩子，那么用其右孩子来替换z，这个右孩子可以是NULL，也可以不是。当右孩子为NULL时，此时这种情况归为z没有孩子节点的情形，当右孩子非NULL时，此时这种情况就是z仅有一个孩子节点的情况，该孩子是右孩子；

        b>

                                  Z

                                /    \                  ------>              L        

                              L     NULL                               /   \

                            /   \

                                           (b)

               如图（b）所示，如果z仅有一个孩子为左孩子，那么用其左孩子来替换z；否则z既有一个左孩子又有一个右孩子。我们要查找z的后继y，这个后继位于z的右子树并且没有左孩子，则需要将y移出原来的位置进行拼接，并替换树中的z。

        c>

                                  Z

                                /   \

                              L     Y                      ------->                            Y

                                    /   \                                                          /    \

                              NULL  X                                                    L      X

                                          /  \                                                 /   \     /   \

               如图（c）所示，用y替换z，并仅留下y的右孩子。

        d>

                                   Z

                                 /   \                              Z                  Y                                           Y

                               L    R       ------->        /                    /   \        ------>                      /    \

                             /  \    /  \                       L              NULL  R                                   L     R

                                    Y                         /  \                         /  \                                /  \     /  \

                                  /   \                                                    X                                          X

                            NULL X                                                /  \                                         /  \

                                      /  \

              其代码实现如下：

static Bin_tree tree_transplant(Bin_tree root,Bin_tree u,Bin_tree v)
{
    if(u ->p == NULL){
        root = v;
    }else if(u == u ->p ->left_child){
        u ->p ->left_child = v;
    }else{
        u ->p ->right_child = v;
    }
    if(v != NULL){
        v ->p = u ->p;
    }
    return root;
}
Bin_tree tree_delete(Bin_tree root,Tree_node *value)
{
    Tree_node *p_node = NULL;
    if(root == NULL || value == NULL){
        return;
    }    
    if(value ->left_child == NULL){
        root = tree_transplant(root,value,value ->right_child);
    }else if(value ->right_child == NULL){
        root = tree_transplant(root,value,value ->left_child);
    }else {
        p_node = get_tree_minnum(value ->right_child);
        if(p_node ->p != value){
            root = tree_transplant(root,p_node,p_node ->right_child);
            p_node ->right_child = value ->right_child;
            p_node ->right_child ->p = p_node; 
        }
        root = tree_transplant(root,value,p_node);
        p_node ->left_child = value ->left_child;
        p_node ->left_child ->p = p_node;
    }
    return root;
}
接下来我们看测试程序的书写： 
#include <stdio.h>
#include <stdlib.h>
#include "binaryserach_tree.h"

int main(int argc,char **argv)
{
    int a[N] = {15,6,18,3,7,17,20,2,4,13};
    Bin_tree root = NULL;
    Tree_node *p_node = NULL;
    Tree_node *node = NULL;
    Tree_node *node1 = NULL;
    root = creat_tree(a,N);
    #if 0 
    printf("level_order:\n");
    level_order_print(root); 
    printf("\n");

    printf("pre_order:\n");
    pre_order_print(root);
    printf("\n");

    printf("mid_order:\n");
    mid_order_print(root);
    printf("\n");

    printf("last_order:\n");
    last_order_print(root);
    printf("\n");

    printf("pre_order_nr:\n");
    pre_order_print_nr(root);
    printf("\n");

    printf("mid_order_nr:\n");
    mid_order_print_nr(root);
    printf("\n");

    printf("last_order_nr:\n");
    last_order_print_nr(root);
    printf("\n");
    #endif
    #if 1
    p_node = Tree_serach(root,6);
    if(p_node){
        printf("%d is found !\n",p_node ->data);
    }else{
        printf(" is not found !\n");
    }

    p_node = Tree_serach(root,18);
    if(p_node){
        printf("%d is found !\n",p_node ->data);
    }else{
        printf(" is not found !\n");
    }

    p_node = Tree_serach_nr(root,9);
    if(p_node){
        printf("%d is found !\n",p_node ->data);
    }else{
        printf(" is not found !\n");
    }
    #endif
    #if 0
    p_node = get_tree_minnum(root);
    if(p_node){
        printf("minnum :%d\n",p_node ->data);
    }

    p_node = get_tree_maxnum(root);
    if(p_node){
        printf("maxnum :%d\n",p_node ->data);
    }

    p_node = tree_successor(root);
    if(p_node){
        printf("root:%d\n",p_node ->data);

    }else{
        printf("root:not found!\n");
    }

    p_node = tree_successor(root ->right_child ->right_child);
    if(p_node){
        printf("root ->right_child ->right_child:%d\n",p_node ->data);
    }else{
        printf("root ->right_child ->right_child:not found!\n");
    }
    
    p_node = tree_successor(root ->left_child ->left_child);
    if(p_node){
        printf("root ->left_child ->left_child:%d\n",p_node ->data);
    }else{
        printf("root ->left_child->left_child:not found !\n");
    }

    p_node = tree_successor(root ->right_child ->left_child);
    if(p_node){
        printf("root ->right_child ->left_child:%d\n",p_node ->data);
    }else{
        printf("root ->right_child->left_child:not found !\n");
    }

    p_node = tree_successor(root ->left_child ->left_child ->right_child);
    if(p_node){
        printf("root ->left_child ->left_child->right_child:%d\n",p_node ->data);
    }else{
        printf("root ->left_child ->left_child->right_child:not found !\n");
    }

    //二叉搜索树的插入：
    node = (Tree_node *)Malloc(sizeof(Tree_node));
    node ->data = 10;
    node ->left_child = NULL;
    node ->right_child = NULL;
    node ->p = NULL;
    tree_insert(root,node);

    printf("mid_order_nr:\n");
    mid_order_print_nr(root);
    printf("\n");

    node1 = (Tree_node *)Malloc(sizeof(Tree_node));
    node1 ->data = 19;
    node1 ->left_child = NULL;
    node1 ->right_child = NULL;
    node1 ->p = NULL;
    tree_insert(root,node1);

    printf("mid_order_nr:\n");
    mid_order_print_nr(root);
    printf("\n");


    p_node = root ->right_child;
    root = tree_delete(root,p_node);
    printf("delete root ->right_child:%d\n",p_node ->data);
    printf("mid_order_nr:\n");
    mid_order_print_nr(root);
    printf("\n");

    root = tree_delete(root,node1);
    printf("delete node1:%d\n",node1 ->data);
    printf("mid_order_nr:\n");
    mid_order_print_nr(root);
    printf("\n");

    root = tree_delete(root,node);
    printf("delete node:%d\n",node->data);
    printf("mid_order_nr:\n");
    mid_order_print_nr(root);
    printf("\n");

    p_node = root;
    root = tree_delete(root,p_node);
    printf("delete root:%d\n",p_node->data);
    printf("mid_order_nr:\n");
    mid_order_print_nr(root);
    printf("\n");
    #endif
    //destroy_tree(&root);
    destroy_tree_nr(&root);
    return 0;
}
我们先来看其测试结果：


为了方便大家理解程序，我跟大家大致画出最初创建出的二叉树：
                                                                       15

                                                                   /         \

                                                               6              18

                                                           /      \          /       \

                                                         3       7       17      20

                                                       /    \        \

                                                     2     4       13

把节点10和19插入到二叉搜索树中后：

                                                                      15

                                                                   /         \

                                                               6              18

                                                           /      \          /       \

                                                         3         7       17      20

                                                       /    \           \        \

                                                     2     4          13    19

                                                                         /

                                                                       10


至此二叉搜索树的实现已完成，此后会和大家一起讨论红黑树、B树、AVL树等等，敬请期待！！！！

fantasy_linux
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《算法导论》第十二章——二叉搜索树
T的博客
10-21 389
  虽然写这个博客主要目的是为了给我自己做一个思路记忆录，但是如果你恰好点了进来，那么先对你说一声欢迎。我并不是什么大触，只是一个菜菜的学生，如果您发现了什么错误或者您对于某些地方有更好的意见，非常欢迎您的斧正！ 12.1什么是二叉搜索树   一棵二叉搜索树是以二叉树来组织的。除了key和卫星数据之外，每个结点还包含属性left、right和parent，它们分别指向结点的左孩子、右孩子和父亲...
JDK1.8ConcurrentHashMap源码解析第三部分（红黑树TreeNode的封装类TreeBin）
weixin_43478710的博客
11-15 1001
TreeBin是红黑树TreeNode的封装类，和TreeNode的区别是有一个成员变量lockState表示锁的状态，还有waiter表示等待的线程，多了几个和锁有关的方法，其他都和TreeNode大致一样 static final class TreeBin<K,V> extends Node<K,V> { TreeNode<K,V> root; //根节点 volatile TreeNode<K,V> first; //
Bintree二叉树实现
weixin_41631293的博客
03-28 312
二叉树的实现 学堂在线-数据结构-二叉树 环境：DEV C++5.4.0。有课程资源但是无法运行，于是自己结合视频，敲了一边，函数名称尽量与视频中统一，有细微的不同。我自己写的部分注释掉了 二叉树的先序、中序、层次遍历栈（实现）和递归实现方法，孩子插入、删除、树的高度等。 二叉树的结点结构体头文件 实现了二叉树的父、孩子的插入，中序遍历下的直接后继等。 #ifndef _BINNODE_HPP #...
下列代码的功能是计算给定二叉树T的宽度。二叉树的宽度是指各层结点数的最大值。函数Queue_rear和Queue_front分别返回当前队列Q中队尾和队首元素的位置。...
Noahの梦想
05-14 2649
typedef struct TreeNode* BinTree; struct TreeNode { int Key; BinTree Left; BinTree Right; }; int Width(BinTree T) { BinTree p; Queue Q; int Last, temp_width, max_width; ...
浙大数据结构-二叉树的遍历算法及拓展
m0_46569480的博客
04-14 287
1.递归版本 1.先序遍历 访问根结点 先序遍历左子树 先序遍历右子树 typedef struct TreeNode *BinTree; typedef struct{ int Data; BinTree lchild; BinTree rchild; } TreeNode; void PreOrderTraversal( BinTree BT){ if( BT ){ printf("%d", BT->Data); PreOrderTraversal( BT->lc
javascript数据结构之二叉搜索树实现方法
10-23
主要介绍了javascript数据结构之二叉搜索树实现方法,较为详细的分析了二叉搜索树的概念、原理与JavaScript实现二叉搜索树的方法,对于学习JavaScript数据结构具有一定参考借鉴价值,需要的朋友可以参考下
数据结构平衡二叉排序树
02-13
AVL树是一种自平衡的二叉搜索树，它的每个节点都包含一个平衡因子，这个因子是该节点的左子树高度与右子树高度的差值。平衡因子的取值范围是-1、0或1，这确保了树的高度始终保持在一个相对较小的范围内，从而保证了...
陈越、何钦铭-数据结构作业12：是否同一棵二叉搜索树
04-20
给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的...
JavaScript数据结构之二叉查找树的定义与表示方法
10-20
本文介绍的JavaScript数据结构之二叉查找树的定义与表示方法，对于理解树的结构和操作至关重要。 首先，树是由节点组成的一个有限集合，每个节点由一个值和若干指向其子树的分支组成。树的根是顶层的节点，而每个...
浙江大学MOOC数据结构-陈越、何钦铭 编程练习题（第四讲）
qq_39309050的博客
06-06 500
浙江大学MOOC数据结构-陈越、何钦铭 编程练习题（第四讲） 编程题目 编程说明 编程环境：平台运行 编程语言：C 第一题代码 #include <stdio.h> #include <stdlib.h> typedef struct TreeNode *Tree; struct TreeNode { int v; Tree Left,Right; int flag; }; Tree MakeTree(int N); Tree NewNode(int
二叉树类BinTree的声明
blacop的博客
03-27 1913
#pragma once #include "stdafx.h" #include "BinTreeNode.h" #include "Stack.h" //二叉树类BinTree的声明 template <typename T> class BinTree { private: //指向根结点 BinTreeNode<T>* root; //输入stop时，终止结点的输入
{1,2,3,4,5,6}集合可以构造多少个二叉排序树
sinat_34139679的博客
04-11 2907
{1,2,3,4,5,6}集合可以构造多少个二叉排序树 卡特兰数   h(n)= h(0)*h(n-1)+h(1)*h(n-2) + ... + h(n-1)*h(0) (n>=2)
寻找二叉树双亲结点
gy77
02-25 3836
/* * @Issue: 寻找X结点的双亲结点 * @Author: 一届书生 * @LastEditTime: 2020-02-25 16:50:27 */ #include<iostream> using namespace std; #define type char typedef struct node{ type data; node ...
week5 4-1 CheckBST[1]
kaggle expert，全球排名前1000，清华计算机研究生，兴趣算法工程
04-08 1498
4-1CheckBST[1](13分) Given a binary tree, you are supposed to tell if it is a binary search tree. If the answer is yes, try to find theKK-th largest key, else try to find the height of the tree. ...
数据结构作业12—树和森林（程序填空题）
banya1999的博客
12-22 1495
5-1下列代码的功能是计算给定二叉树T的宽度。二叉树的宽度是指各层结点数的最大值。函数Queue_rear和Queue_front分别返回当前队列Q中队尾和队首元素的位置。 typedef struct TreeNode *BinTree; struct TreeNode { int Key; BinTree Left; BinTree Right; }; int Widt...
Bintree(二叉树)
CallmeDaChang的博客
05-16 2605
阐述一下二叉树的理解1.二叉树的一些性质 二叉树性质 在二叉树的第i层上至多有2i-1个结点（i≥1） 深度为k的二叉树至多有2k-1个结点（k≥1） 对任何一棵二叉树，如果其终端结点数为n0，度为2的结点数为n2，则n0=n2+1 左子树的所有节点小于父节点 有字数的所有节点大于父节点 满二叉树 1. 一棵深度为k且有2k-1个结点的二叉树称为满二叉树。完全二叉树可以对满二叉树的结点进行连
求二叉树的宽度
HHHHHHep的博客
12-19 4763
5-1 下列代码的功能是计算给定二叉树T的宽度。二叉树的宽度是指各层结点数的最大值。函数Queue_rear和Queue_front分别返回当前队列Q中队尾和队首元素的位置。 typedef struct TreeNode *BinTree; struct TreeNode { int Key; BinTree Left; BinTree Right; }; i
能构成的二叉查找树的个数 Unique Binary Search Trees
LUCKYOJ
11-07 2301
题目源自于Leetcode。 题目：Given n, how many structurally unique BST's (binary search trees) that store values 1...n? For example, Given n = 3, there are a total of 5 unique BST's. 1 3
第04次作业-树
weixin_30425949的博客
05-05 154
1.学习总结 1.1树结构思维导图 1.2树结构学习体会 1)树的结构：非线性结构，也是递归型的结构，属于集合之间的关系。 2树和二叉树是难点，但着实是重点,树的一些基本计算公式应牢记。 3)课本递归好理解，真正自己写的时候总是无从下手，PTA更需多加练习。 4)学完树，更加体会到写代码之前学写伪代码的重要性。 2.PTA实验作业 题目一:6-4 jmu-ds-表达式树（25 分） 2.设...
二叉搜索树构建与特性分析-数据结构讲义
二叉搜索树（BST）是一种重要的数据结构，它的主要特点是每个节点的左子树只包含比当前节点小的元素，右子树包含比当前节点大的元素。这种特性使得二叉搜索树在查找、插入和删除操作中有着较高的效率，因为搜索路径...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值