数据结构之二叉树的创建

最新推荐文章于 2024-04-30 20:54:55 发布
最新推荐文章于 2024-04-30 20:54:55 发布
阅读量9w 收藏 557
点赞数 128
分类专栏： C语言 算法和数据结构 文章标签： 二叉树 数据结构 C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014754841/article/details/79361772
版权

文章开头首先要感谢一下国嵌嵌入式教育的工作者们。

创建二叉树 

二叉树不仅比通用树结构简练，而且同时拥有通用树相同的操作。要想创建二叉树，首先就得了解一下二叉树的存储结构。已知二叉树的存储结构分为顺序存储结构和链式存储结构。其中链式存储结构又分为二叉链表和三叉链表。

1. 顺序存储结构：

按照顺序存储结构的定义，在此约定用一组地址连续的存储单元一次自上而下、自左至右存储完全二叉树上的节点元素，即将完全二叉树上编号为i的结点元素存储在如上定义的一维数组中下标为i-1的分量中。如下表1所示为图1所示的完全二叉树的顺序存储结构:

  图1

表1

1

2

3

4

5

6

7

8

9

10

对于一般二叉树，则将其每一个结点与完全二叉树的结点相对照，存储在一维数组的相应分量中，如下表2所示图2所示的非完全二叉树的顺序存储结构:：

  图2

表2

1

2

3

4

5

0

6

0

7

8

图中“0”表示不存在此结点。由此可见顺序存储结构仅适用于完全二叉树。因为，在最坏的情况下，一个深度为k且只有k个结点的单枝树（树中不存在度为2的结点）却需要长度为2k-1的一维数组。造成存储内存的浪费。

链式存储结构：

设计不同的结点结构可构成不同形式的链式存储结构。由二叉树的定义得知，二叉树的结点由一个数据元素和分别指向其左、右子树的两个分支构成，则表示二叉树的链表中的结点至少包含3个域：数据域和左、右指针域。如下所示：

Lchid

Data

Rchild

有时，为了便于找到结点的双亲，则还可在结点结构中增加一个指向其双亲结点的指针域，如下所示：

Lchild

Data

Parent

Rchild

利用这两种结点结构所得的二叉树的存储结构分别称之为二叉链表和三叉链表。链表的头指针指向二叉树的根结点。因此，我们可知在含有n个节点的二叉链表中有n+1个空链域用于存放二叉树结点。到此，我们应该明白可以通过单链表的实现思想来创建二叉树。单链表内容参考单链表C语言实现

我们接下来讲一下如何通过二叉链表链式存储结构对二叉树进行操作，其重点就是如何在二叉树中定位结点的位置？那么如何定位呢？

现实生活中我们总会遇到问路的情况，指路的人一般都会说直走、到哪个路口左拐，到哪个路口右拐。这就让我们联想到二叉树的结点是否可以类比成现实中的路口，它的两个子树是否可以当做左拐或右拐呢？

因此，前辈们想出了指路法定位结点:


指路法通过根结点与目标结点的相对位置进行定位，指路法可以避开二叉树递归的性质“线性”定位。

思想：在C语言中可以利用bit位进行指路。。。



用结构体来定义二叉树中的指针域，二叉树的头结点与数据域也可以用结构体实现。

二叉树的重点操作是定位，下面我们看一下定位操作：


定位的关键技巧：

1.利用二进制中的0和1分别表示left和right；

2.位运算是实现指路法的基础。

至此，我们就可以来实现二叉树的相关操作了，上代码。

首先定义相关结构体及其他变量

#define BT_LEFT 0            //  左边
#define BT_RIGHT 1           //  右边
// 定义新数据类型，用于封装函数
typedef void BTree;
typedef unsigned long long BTPos;
// 定义二叉树左右指针结构体
typedef struct _tag_BTreeNode BTreeNode;
struct _tag_BTreeNode
{
    BTreeNode* left;         // 二叉树左结点指针
    BTreeNode* right;        // 二叉树右结点指针
};

// 定义二叉树根结点结构体
typedef struct _tag_BTree TBTree;
struct _tag_BTree
{
    int count;                // 记录二叉树结点个数
    BTreeNode* root;          // 二叉树结点指针结构体，指向根结点
};
1.创建二叉树 
// 创建二叉树
BTree* BTree_Create() // O(1)
{
    // 定义二叉树结点结构体变量，并申请内存
    TBTree* ret = (TBTree*)malloc(sizeof(TBTree));
    // 申请成功，初始化二叉树为空树
    if( ret != NULL )
    {
        ret->count = 0;
        ret->root = NULL;
    }
    
    return ret;
}

创建二叉树比较简单，等同于简单的单链表创建方法。所以销毁和清空二叉树也会单链表的操作雷同。

2.销毁与清空单链表

// 销毁二叉树
void BTree_Destroy(BTree* tree) // O(1)
{
    free(tree);       // 释放内存
}
// 清空二叉树
void BTree_Clear(BTree* tree) // O(1)
{
    // 定义二叉树结点结构体变量，强制转换入口参数
    TBTree* btree = (TBTree*)tree;
    // 参数合法性OK，将二叉树置为空树
    if( btree != NULL )
    {
        btree->count = 0;
        btree->root = NULL;
    }
}

3.插入结点

插入结点是二叉树操作的重点，代码如下：

// 在二叉树指定位置pos插入结点node
// pos：定位的方向，二进制：0表示左，1表示右
// count:定位次数，移动指针次数
// flag：插入方向 BT_LEFT or BT_RIGHT
int BTree_Insert(BTree* tree, BTreeNode* node, BTPos pos, int count, int flag) // O(n) 
{
    // 定义二叉树结点结构体变量，强制转换入口参数
    TBTree* btree = (TBTree*)tree;    
    // 入口参数合法性检查，插入的二叉树不为空，插入的结点不为空，插入方向正确
    int ret = (btree != NULL) && (node != NULL) && ((flag == BT_LEFT) || (flag == BT_RIGHT));
    int bit = 0;
    // 入口参数合法性ok
    if( ret )
    {
    	// 定义二叉树左右指针结构体临时变量
        BTreeNode* parent = NULL;
    	// 定义二叉树左右指针结构体变量，存放当前结点地址
        BTreeNode* current = btree->root;
        // 初始化插入结点的左右指针地址，默认为NULL
        node->left = NULL;
        node->right = NULL;
        // 开始定位  定位次数不为零，插入的位置不是根结点
        while( (count > 0) && (current != NULL) )
        {
            // 取定位方向参数最右边bit位用于判断左右
            bit = pos & 1;
            pos = pos >> 1;
            // 临时变量更新当前指针，保存插入结点位置的双亲指针
            parent = current;
            // 左边,向左移动指针
            if( bit == BT_LEFT )
            {
                current = current->left;        // 将当前结点指针指向左边子结点指针
            }
            // 右边,向右移动指针
            else if( bit == BT_RIGHT )
            {
                current = current->right;       // 将当前结点指针指向右边子结点指针
            }
            // 定位次数减1
            count--;
        }
        // 定位完成后，判断待插入结点的插入位置
        // 左边
        if( flag == BT_LEFT )
        {
            node->left = current;           // 将带插入结点的左指针指向当前结点
        }
        // 右边
        else if( flag == BT_RIGHT )
        {
            node->right = current;          // 将待插入结点的右指针指向当前结点
        }
        // 当前结点指针不为空，即不是根结点
        if( parent != NULL )
        {
            // 左边
            if( bit == BT_LEFT )
            {
                parent->left = node;         // 将插入结点位置的双亲指针的左指针指向待插入结点
            }
            // 右边
            else if( bit == BT_RIGHT )
            {
                parent->right = node;        // 将插入结点位置的双亲指针的右指针指向待插入结点
            }
        }
        // 插入的是首结点，即根结点
        else
        {
            btree->root = node;              // 将根结点指向待插入结点
        }
        // 二叉树结点个数加1
        btree->count++;
    }
    
    return ret;
}

通过上面的代码，我们发现二叉树的插入与单链表的参入操作实现方式基本雷同，不同的就是二叉树指针分左右，双指针操作，而单链表操作的指针只有一个next。插入的重点是先根据参数定好位置同时时刻更新找到的新位置，然后根据插入的方向将找到的位置的左或右左右指针指向要插入的结点地址，将要插入的结点地址的左右指针指向相对应的原来位置的左右指针位置。

4.显示二叉树

插入的二叉树，就要验证一下插入的是否正确，所以我们通过二叉树的显示函数来显示二叉树的元素，来验证插入的正确性。代码如下：

// 显示二叉树
void BTree_Display(BTree* tree, BTree_Printf* pFunc, int gap, char div) // O(n)
{
	  // 定义二叉树结点结构体变量，强制转换入口参数
    TBTree* btree = (TBTree*)tree;
    // 合法性检查OK，调用显示递归函数
    if( btree != NULL )
    {
        recursive_display(btree->root, pFunc, 0, gap, div);
    }
}

同通用树一样，二叉树的显示函数也需要递归来实现，递归实现代码如下：

// 显示递归函数
static void recursive_display(BTreeNode* node, BTree_Printf* pFunc, int format, int gap, char div) // O(n)
{
    int i = 0;
    // 合法性检查OK
    if( (node != NULL) && (pFunc != NULL) )
    {
    	// 打印格式符
        for(i=0; i<format; i++)
        {
            printf("%c", div);
        }
        // 打印内容
        pFunc(node);
        
        printf("\n");
        // 存在左子树结点或存在右子树结点
        if( (node->left != NULL) || (node->right != NULL) )
        {
 
            recursive_display(node->left, pFunc, format + gap, gap, div);      // 调用递归函数打印左子树结点
            recursive_display(node->right, pFunc, format + gap, gap, div);     // 调用递归函数打印右子树结点
        }
    }
    // 根结点为空
    else
    {    	  
    	  // 打印格式符
        for(i=0; i<format; i++)
        {
            printf("%c", div);
        }
        printf("\n");
    }
}

与通用树不同的地方就是二叉树需要分左右显示。

5.删除指定结点

// 删除指定位置的结点
BTreeNode* BTree_Delete(BTree* tree, BTPos pos, int count) // O(n)
{
    // 定义二叉树结点结构体变量，强制转换入口参数
    TBTree* btree = (TBTree*)tree;
    // 定义返回变量
    BTreeNode* ret = NULL; 
    int bit = 0;    
	  // 入口参数合法性检查ok
    if( btree != NULL )
    {
    	  // 定义二叉树左右指针结构体临时变量
        BTreeNode* parent = NULL;
    	  // 定义二叉树左右指针结构体变量，存放当前结点地址
        BTreeNode* current = btree->root;        
        // 开始定位  定位次数不为零，删除的位置不是根结点
        while( (count > 0) && (current != NULL) )
        {
            // 取定位方向参数最右边bit位用于判断左右
            bit = pos & 1;
            pos = pos >> 1;
            
            // 临时变量更新当前指针，保存删除结点位置的双亲指针
            parent = current;            
            // 左边,向左移动指针
            if( bit == BT_LEFT )
            {
                current = current->left;         // 将删除结点位置的双亲指针的左指针指向待删除结点
            }
            // 右边,向右移动指针
            else if( bit == BT_RIGHT )
            {
                current = current->right;        // 将删除结点位置的双亲指针的右指针指向待删除结点
            }
            // 定位次数减1             
            count--;
        }        
        // 当前结点指针不为空，即不是根结点
        if( parent != NULL )
        {
            // 左边
            if( bit == BT_LEFT )
            {
                parent->left = NULL;         // 将结点左子树位置指向空指针，即删除左结点
            }
            // 右边
            else if( bit == BT_RIGHT )
            {
                parent->right = NULL;        // 将结点右子树位置指向空指针，即删除右结点
            }
        }
        // 删除的是首结点，即根结点
        else
        {
            btree->root = NULL;              // 将根结点指向空指针，即删除所有结点
        }
        // 返回删除元素结点
        ret = current;
        // 更新二叉树结点个数，结点个数减去删除的结点个数
        btree->count = btree->count - recursive_count(ret);
    }
    
    return ret;
}

删除结点的操作重点和插入一样，首先通过参数定位到要删除的结点，然后根据要删除的方向将该结点的左或右指针指向NULL即可。需要主要的是二叉树的数量更新不是单单的减1就行的，这得需要根据删除的结点来计算出该结点相应子树下的所有结点个数，然后减去这个个数才行btree->count = btree->count - recursive_count(ret);
，所以我们同个一个递归函数求结点个数。递归函数代码如下：

// 求二叉树结点子树结点个数
static int recursive_count(BTreeNode* root) // O(n)
{
    int ret = 0;
    // 合法性检查ok
    if( root != NULL )
    {
        ret = recursive_count(root->left) + 1 + recursive_count(root->right);    // 调用递归函数计算个数
    }
    // 返回个数
    return ret;
}

6.获取指定结点

// 获取指定位置的结点
BTreeNode* BTree_Get(BTree* tree, BTPos pos, int count) // O(n)
{
    // 定义二叉树结点结构体变量，强制转换入口参数
    TBTree* btree = (TBTree*)tree;
    // 定义返回变量
    BTreeNode* ret = NULL; 
    int bit = 0;
    
    // 入口参数合法性检查ok
    if( btree != NULL )
    {
    	// 定义二叉树左右指针结构体变量，存放当前结点地址
        BTreeNode* current = btree->root;        
        // 开始定位  定位次数不为零，删除的位置不是根结点
        while( (count > 0) && (current != NULL) )
        {
            // 取定位方向参数最右边bit位用于判断左右
            bit = pos & 1;
            pos = pos >> 1;
            
            // 左边,向左移动指针
            if( bit == BT_LEFT )
            {
                current = current->left;
            }
            // 右边,向右移动指针
            else if( bit == BT_RIGHT )
            {
                current = current->right;
            }
            
            // 定位次数减1   
            count--;
        }
        
        ret = current;
    }
    
    return ret;
}

获取指定位置的结点，首先就是定位置到要获取的位置，然后返回该结点的地址即可。

7.获取根结点

// 获取根结点
BTreeNode* BTree_Root(BTree* tree) // O(1)
{
    // 定义二叉树结点结构体变量，强制转换入口参数
    TBTree* btree = (TBTree*)tree;
    // 定义返回变量
    BTreeNode* ret = NULL;
    // 入口参数合法性检查ok，返回根结点地址
    if( btree != NULL )
    {
        ret = btree->root;
    }
    
    return ret;
}

获取根结点就是获取二叉树的头结点，直接返回头结点地址即可。

8.获取二叉树的高度（深度）

// 获取二叉树高度
int BTree_Height(BTree* tree) // O(n)
{
    // 定义二叉树结点结构体变量，强制转换入口参数
    TBTree* btree = (TBTree*)tree;
    // 定义返回变量
    int ret = 0;    
    // 入口参数合法性检查ok，调用递归函数求二叉树高度
    if( btree != NULL )
    {
        ret = recursive_height(btree->root);
    }
    // 返回二叉树高度
    return ret;
}

和通用树一样，二叉树的高度获取也需要递归来实现，递归函数代码如下：

// 求二叉树高度递归函数
static int recursive_height(BTreeNode* root) // O(n)
{
    // 定义返回值变量
    int ret = 0;
    // 入口参数合法性检查OK
    if( root != NULL )
    {
        int lh = recursive_height(root->left);       // 求左子树高度
        int rh = recursive_height(root->right);      // 求右子树高度
        // 求左右子树高度最大值
        ret = ((lh > rh) ? lh : rh) + 1;
    }
    // 返回二叉树高度
    return ret;
}

分别求左右子树的高度，然后比较出最大值返回。

9.获取二叉树的度

// 获取二叉树度
int BTree_Degree(BTree* tree) // O(n)
{
	  // 定义二叉树结点结构体变量，强制转换入口参数
    TBTree* btree = (TBTree*)tree;
    // 定义返回变量
    int ret = 0;    
	  // 入口参数合法性检查ok，调用求二叉树度递归函数
    if( btree != NULL )
    {
        ret = recursive_degree(btree->root);
    }
    // 返回二叉树的度
    return ret;
}
和通用树一样，二叉树的度获取也需要递归来实现，递归函数代码如下： 
// 求二叉树度递归函数，最大度为2
static int recursive_degree(BTreeNode* root) // O(n)
{
	  // 定义返回值变量
    int ret = 0;    
    // 入口参数合法性检查OK
    if( root != NULL )
    {
    	  // 左子树结点不为空，度加1
        if( root->left != NULL )
        {
            ret++;
        }        
    	  // 右子树结点不为空，度加1
        if( root->right != NULL )
        {
            ret++;
        }
        // 度为1，调用递归函数求其他结点度
        if( ret == 1 )
        {
            int ld = recursive_degree(root->left);       // 求左子树结点的度
            int rd = recursive_degree(root->right);      // 求右子树结点的度
            // 求左子树结点度的最大值
            if( ret < ld )
            {
                ret = ld;
            }            
            // 求右子树结点度的最大值
            if( ret < rd )
            {
                ret = rd;
            }
        }
    }
    // 返回度
    return ret;
}

因为二叉树的度最大也就是2，所以只有在当前求得度为1时才需要调用递归函数来求其他子树结点的度。

验证代码如下：

#include <stdio.h>
#include <stdlib.h>
#include "BTree.h"

/* run this program using the console pauser or add your own getch, system("pause") or input loop */
// 定义二叉树数据域结构体
struct Node
{
    BTreeNode header;
    char v;
};
// 定义打印内容函数
void printf_data(BTreeNode* node)
{
    if( node != NULL )
    {
        printf("%c", ((struct Node*)node)->v);
    }
}

int main(int argc, char *argv[])
{
	  // 创建二叉树
    BTree* tree = BTree_Create();
    // 定义要插入结点元素
    struct Node n1 = {{NULL, NULL}, 'A'};
    struct Node n2 = {{NULL, NULL}, 'B'};
    struct Node n3 = {{NULL, NULL}, 'C'};
    struct Node n4 = {{NULL, NULL}, 'D'};
    struct Node n5 = {{NULL, NULL}, 'E'};
    struct Node n6 = {{NULL, NULL}, 'F'};    
    // 插入结点元素
    BTree_Insert(tree, (BTreeNode*)&n1, 0, 0, 0);
    BTree_Insert(tree, (BTreeNode*)&n2, 0x00, 1, 0);
    BTree_Insert(tree, (BTreeNode*)&n3, 0x01, 1, 0);
    BTree_Insert(tree, (BTreeNode*)&n4, 0x00, 2, 0);
    BTree_Insert(tree, (BTreeNode*)&n5, 0x02, 2, 0);
    BTree_Insert(tree, (BTreeNode*)&n6, 0x02, 3, 0);
    // 打印相应提示内容
    printf("Height: %d\n", BTree_Height(tree));
    printf("Degree: %d\n", BTree_Degree(tree));
    printf("Count: %d\n", BTree_Count(tree));
    printf("Position At (0x02, 2): %c\n", ((struct Node*)BTree_Get(tree, 0x02, 2))->v);
    printf("Full Tree: \n");
    // 显示二叉树
    BTree_Display(tree, printf_data, 4, '-');
    // 测试删除结点功能
    BTree_Delete(tree, 0x00, 1);   
    // 打印相应提示内容
    printf("After Delete B: \n");
    printf("Height: %d\n", BTree_Height(tree));
    printf("Degree: %d\n", BTree_Degree(tree));
    printf("Count: %d\n", BTree_Count(tree));
    printf("Full Tree: \n");    
    // 显示删除结点后的二叉树
    BTree_Display(tree, printf_data, 4, '-');
    
    // 测试清空二叉树功能
    BTree_Clear(tree);    
    // 打印相应提示内容
    printf("After Clear: \n");
    printf("Height: %d\n", BTree_Height(tree));
    printf("Degree: %d\n", BTree_Degree(tree));
    printf("Count: %d\n", BTree_Count(tree));    
    // 显示清空后的二叉树
    BTree_Display(tree, printf_data, 4, '-');
    // 销毁二叉树
    BTree_Destroy(tree);
    
	return 0;
}

通过理解相关实现代码，我们发现通过指路法可以方便的定位二叉树中的结点，基于指路法的二叉树在插入，删除和获取操作的实现细节上与单链表相似。

整体实现代码： 二叉树C语言实现代码
顾小豆
关注
  • 128
    点赞
  • 踩
  • 557
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
【数据结构】二叉链表创建二叉树（C语言版）
咖喱年糕的博客
02-12 1331
第一步先创建根节点,然后创建根节点左子树,开始递归创建左子树，直到递归创建到的节点下不继续创建左子树，也就是当下递归到的节点下的左子树指向NULL，结束本次左子树递归，返回这个节点的上一个节点，开始创建右子树，然后又开始以当下这个节点，继续递归创建左子树，左子树递归创建完，就递归创建右子树，直到递归结束返回到上一级指针节点（也就是根节点下），此时根节点左边子树创建完毕，开始创建右边子树，原理和根节点左边创建左右子树相同。二叉树的操作通常使用递归方法，如果递归不太明白，建议去对此进行一下学习和练习。
二叉树的创建和遍历
zuojiejie的博客
11-29 6056
二叉树的创建可以选择顺序存储方式创建二叉树和链式存储方式创建二叉树。我们为了创建一棵完整的二叉树，需要对普通的二叉树进行拓展，如图所示：其实建立二叉树也是利用了递归的原理。只不过在原来应该是打印结点的地方，改成了生成结点，给结点赋值的操作而已。大家可以先看后面的二叉树的遍历，再来看二叉树的创建。
二叉树详细介绍与代码生成遍历
最新发布
ximu__l的博客
04-30 696
介绍了树的概念和表示，二叉树的分类，以及每一类的介绍，二叉树的构造、结构。以及二叉树的遍历和代码展示
数据结构之二叉树（详细版）
xk972414831的博客
09-20 1875
二叉树作为数据结构的一种，尤为重要，下面是对二叉树的详细讲解。想要了解二叉树，首先要了解二叉树的基本概念，以及创建二叉树的结构，再深层点，遍历二叉树的前序中序和后续，其次是层序，后面将会讲解如何计算二叉树的高和叶结点等等。 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 有一个特殊的结点，称为根结点，根节点没有前驱结点 除根节点外，其余结点被分成M(M>0)
数据结构 —— 二叉树（超详细图解 & 接口函数实现）
十里坡小白的博客
09-02 1790
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。数据结构是一种十分优秀的解决实际问题的模板，博主将会用代码结合大量图解，对数据结构进行深度剖析。
二叉树相关操作的实现
m0_52387040的博客
05-10 421
实 验 报 告 实验名称 二叉树相关操作的实现 一、实验目的和要求 1.理解二叉树二叉链表的存储结构。 2.以二叉树二叉链表的存储结构，实现二叉树的基本操作。 3.掌握二叉树二叉链表存储结构下，相关递归算法的实现。 二、实验内容: （一）完成二叉树二叉链表结构的定义 （二）实现二叉链表创建二叉树，并实现先序、中序和后序遍历算法。 （三）实现二叉树求结点个数，求树的高度，求叶子结点数、交换二叉树左右子树的算法。 三、实验环境(实验设备) Visual Studio等 Visual Studio 2019 实
python数据结构之二叉树的建立实例
12-23
先建立二叉树节点，有一个data数据域，left，right 两个指针域复制代码 代码如下:# -*- coding: utf – 8 – *- class TreeNode(object): def __init__(self, left=0, right=0, data=0): self.left = left self....
C语言数据结构实现二叉树的建立与遍历.cpp
04-18
C语言数据结构实现二叉树的建立与遍历.cpp
合工大数据结构实验 二叉树
04-14
本实验的主题是“二叉树”，这是数据结构中一个基础且重要的概念。二叉树是一种非线性的数据结构，由节点（或称为顶点）组成，每个节点最多有两个子节点，通常称为左子节点和右子节点。这个实验旨在帮助学生深入理解...
数据结构平衡二叉树的操作演示
05-07
数据结构平衡二叉树的操作演示 本篇文章将对平衡二叉树的操作演示进行详细的介绍，包括创建表、查找、插入、删除、合并、分裂六种操作。并对平衡二叉树的实现过程进行了详细的设计和分析。 一、概要设计 平衡...
数据结构实验五（二叉树的建立及遍历）题目和源程序
04-02
实验内容 1．编写程序任意输入二叉树的结点个数和结点值，构造一棵二叉树，采用三种递归遍历算法(前序、中序、后序)对这棵二叉树进行遍历并计算出二叉树的高度。 2 .编写程序生成下面所示的二叉树，并采用中序遍历的非递归算法对此二叉树进行遍历。
数据结构实验——二叉树的建立和遍历.zip
12-13
1.采用二叉链表作为存储结构，创建一棵二叉树； 2.用递归及非递归算法对二叉树实现先序遍历； 3.用递归及非递归算法对二叉树实现中序遍历； 4.用递归及非递归算法对二叉树实现后序遍历。 5.用递归遍历算法中的访问...
二叉树的创建、先序、中序以及后序遍历
zhonghua18517的专栏
06-01 3386
二叉树结点结构与双链表结点结构式类似的，只是
二叉树
m0_52575604的博客
03-28 452
二叉树的性质 1.二叉树的子树有左右之分，其次序不能颠倒。 2.二叉树的第i层上最多有**2^(i-1)**个结点。 3.深度为k的二叉树最多有2^k-1个结点。 4.设二叉树的总结点数为N，终端（度为0）结点数为N0,度为1的结点数为N1，度为2的结点数为N2，分支总数为B，则有以下关系式： N=N0+N1+N2=B+1; 因为除了根节点以外，其余结点都有分支进入，则有： B=N1+2N2; N=N1+2N2+1; 结合上面式子可得：N0=N2+1，即终端结点数等于度为2的结点数加1； 完全二叉树：深度为
数据结构二叉树的建立（先序）和读取（后序）
qq_42443562的博客
11-13 868
一、二叉树的性质 二叉树的第i层上最多有2i-1个结点（i≥1）。 深度为k的二叉树最多有2k-1个结点（k≥1 ） 一棵非空二叉树，若叶子结点数为n0，度数为2的结点数为n2，则n0=n2+1。 1.1 完全二叉树特有性质 具有n个结点的完全二叉树的深度必为log2n＋1 对于具有n个结点的完全二叉树，如果按照从上到下和从左到右的顺序对二叉树中的所有结点从1开始顺序编号，则对于任意的序...
数据结构-14（二叉树）
Emissary_的博客
05-24 222
二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个节点最多只能有两棵子树，且有左右之分。二叉树是n个有限元素的集合，该集合或者为空、或者由一个称为根的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成，是有序树。当集合为空时，称该二叉树为空二叉树。在二叉树中，一个元素也称作一个节点。 （1）建立队列及二叉树节...
数据结构之二叉树的练习题
容铎的博客
05-21 1110
数据结构之二叉树的练习题
理论基础 —— 二叉树 —— 顺序存储结构
Alex_McAvoy的博客
06-09 6295
【顺序存储结构】 二叉树的顺序存储结构是用一维数组存储二叉树中的结点，并用结点的存储位置表示结点间的逻辑关系（父子关系） 由于二叉树本身不具有顺序关系，因此二叉树的顺序存储结构要解决的关键问题是如何利用数组下标来反映结点间的逻辑关系。 由于完全二叉树中结点的层序编号可以唯一反映结点间的逻辑关系，因此对于一般的二叉树，可以添加一些不存在的空结点，使其成为一棵完全二叉树，再利用一维数组存储。 ...
实验四 二叉树的实现（顺序存储结构）
x1432553805的博客
05-09 6984
一、实验目的1、 熟练理解树和二叉树的相关概念，掌握的存储结构和相关操作实现；2、 掌握树的顺序结构的实现；3、 学会运用树的知识解决实际问题二、实验内容 自己确定一个二叉树（树结点类型、数目和结构自定）利用顺序结构方法存储。实现树的构造，并完成：1） 层序输出结点数据；2） 以合理的格式，输出各个结点和双亲、孩子结点信息；3） 输出所有的叶子结点信息；4）分析你的算法对于给定的二叉树的存储效率。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值