二叉通用树C语言实现---双亲孩子法

最新推荐文章于 2021-10-09 19:27:49 发布
置顶 最新推荐文章于 2021-10-09 19:27:49 发布
阅读量869 收藏 3
点赞数
分类专栏： 数据结构与算法 文章标签： 二叉通用树 递归 C语言 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/coding__madman/article/details/84673811
版权

还是国嵌之前数据结构和算法视频里面唐老师的代码，最近刷二叉树的相关题目，整好拿来用用，先贴源代码，顺便复习一下，老师的代码真的很棒！后边借助老师之前的链表以及栈的实现，非递归实现二叉树的前序遍历、中序遍历、后续遍历、以及层次遍历-全部用栈实现。

目标实现如下二叉树，并且打印结果，

/举例
/************************************
              A
            /    \
           B     C
         /   \    /  \
        D   E F   G
      /   \  / 
     H   I J
*************************************/

先贴代码：

BTree.c

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

// 定义二叉树根结点结构体
typedef struct _tag_BTree TBTree;
struct _tag_BTree
{
    int count;                // 记录二叉树结点个数
    BTreeNode* root;          // 二叉树结点指针结构体，指向树结点根节点
};

// 创建二叉树
BTree* BTree_Create() // O(1)
{
    // 定义二叉树结点结构体变量，并申请内存
    TBTree* ret = (TBTree*)malloc(sizeof(TBTree));

    if( ret != NULL )
    {
        ret->count = 0;
        ret->root = NULL;
    }
    
    return ret;
}

// 销毁二叉树
void BTree_Destroy(BTree* tree) // O(1)
{
    free(tree);       // 释放内存
}

// 清空二叉树
void BTree_Clear(BTree* tree) // O(1)
{

    TBTree* btree = (TBTree*)tree;

    if( btree != NULL )
    {
        btree->count = 0;
        btree->root = NULL;
    }
}

// 在二叉树指定位置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;

    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--;
        }
        // 定位完成后，如果该位置节点已经存在，判断待插入结点的插入位置flag表示插入该节点后，原位置的节点在该节点的左边还是右边
        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;
}

// 显示递归函数
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");
    }
}


// 显示二叉树
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 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;
}



int BTree_Count(BTree* tree)
{

    TBTree* btree = (TBTree*)tree;
    int ret = 0;    
    // 入口参数合法性检查ok，调用递归函数求二叉树高度
    if( btree != NULL )
    {
        ret = recursive_count(btree->root);
    }
    // 返回二叉树高度
    return ret;

}

// 删除指定位置的结点
BTreeNode* BTree_Delete(BTree* tree, BTPos pos, int count) // O(n)
{
    TBTree* btree = (TBTree*)tree;
    BTreeNode* ret = NULL; 
    int bit = 0;    

    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;
}

// 获取指定位置的结点
//如果获取的节点位置为空怎么办 
BTreeNode* BTree_Get(BTree* tree, BTPos pos, int count) // O(n)
{
    // 定义二叉树结点结构体变量，强制转换入口参数
    TBTree* btree = (TBTree*)tree;
    // 定义返回变量
    BTreeNode* ret = NULL; 
    int bit = 0;
    int i = 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;
            }
            //printf("the tree node is %d\n", i++);
            // 定位次数减1   
            count--;
        }
        
        ret = current;
   
    }
    
    return ret;
}

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

// 求二叉树高度递归函数
static int recursive_height(BTreeNode* root) // O(n)
{
    int ret = 0;
    if( root != NULL )
    {
        int lh = recursive_height(root->left);       // 求左子树高度
        int rh = recursive_height(root->right);      // 求右子树高度
        // 求左右子树高度最大值
        ret = ((lh > rh) ? lh : rh) + 1;
    }
    // 返回二叉树高度
    return ret;
}

// 获取二叉树高度
int BTree_Height(BTree* tree) // O(n)
{
    // 定义二叉树结点结构体变量，强制转换入口参数
    TBTree* btree = (TBTree*)tree;
    int ret = 0;    

    if( btree != NULL )
    {
        ret = recursive_height(btree->root);
    }
    // 返回二叉树高度
    return ret;
}

// 求二叉树度递归函数，最大度为2
static int recursive_degree(BTreeNode* root) // O(n)
{

    int ret = 0;    

    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;
}


// 获取二叉树度
int BTree_Degree(BTree* tree) // O(n)
{
    TBTree* btree = (TBTree*)tree;
    int ret = 0;    

    if( btree != NULL )
    {
        ret = recursive_degree(btree->root);
    }
    // 返回二叉树的度
    return ret;
}

BTree.h

#ifndef __BTREE_H_
#define __BTREE_H_
 
#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 void (BTree_Printf)(BTreeNode*);

 
void BTree_Destroy(BTree* tree);

BTree* BTree_Create();

void BTree_Clear(BTree* tree);

int BTree_Insert(BTree* tree, BTreeNode* node, BTPos pos, int count, int flag);

void BTree_Display(BTree* tree, BTree_Printf* pFunc, int gap, char div);

BTreeNode* BTree_Delete(BTree* tree, BTPos pos, int count);

BTreeNode* BTree_Get(BTree* tree, BTPos pos, int count);

BTreeNode* BTree_Root(BTree* tree);

int BTree_Height(BTree* tree);

int BTree_Degree(BTree* tree);

int BTree_Count(BTree* tree);

 
#endif

测试demo :main.c

#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'};
	struct Node n7 = {{NULL, NULL}, 'G'};
	struct Node n8 = {{NULL, NULL}, 'H'};
	struct Node n9 = {{NULL, NULL}, 'I'};
	struct Node n10 = {{NULL, NULL}, 'J'};  
    // 插入结点元素
	// 在二叉树指定位置pos插入结点node
	// pos：定位的方向，二进制：0表示左，1表示右
	// count:定位次数，移动指针次数
	// flag：插入方向 BT_LEFT or BT_RIGHT
	
    BTree_Insert(tree, (BTreeNode*)&n1, 0x00, 0, 0);//A 根节点 
    BTree_Insert(tree, (BTreeNode*)&n2, 0x00, 1, 0);//B
    BTree_Insert(tree, (BTreeNode*)&n3, 0x01, 1, 0);//C
    BTree_Insert(tree, (BTreeNode*)&n4, 0x00, 2, 0);//D
    BTree_Insert(tree, (BTreeNode*)&n5, 0x02, 2, 0);//E
    BTree_Insert(tree, (BTreeNode*)&n6, 0x01, 2, 0);//F
    BTree_Insert(tree, (BTreeNode*)&n7, 0x03, 2, 0);//G
    BTree_Insert(tree, (BTreeNode*)&n8, 0x00, 3, 0);//H
    BTree_Insert(tree, (BTreeNode*)&n9, 0x04, 3, 0);//I
    BTree_Insert(tree, (BTreeNode*)&n10, 0x02, 3, 0);//J
    // 打印相应提示内容
    printf("Height: %d\n", BTree_Height(tree));
    printf("Degree: %d\n", BTree_Degree(tree));
    printf("Count: %d\n", BTree_Count(tree));
    if((struct Node*)BTree_Get(tree, 0x02, 2) != NULL)
    	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;
}

部分测试运行结果：

/************************************
              A
            /    \
           B     C
         /   \    /  \
        D   E F   G
      /   \  / 
     H   I J
*************************************/

二叉树里面好多接口函数用到了递归，递归本质其实就是一个栈结构，用递归能实现的，用栈都可以实现。该代码精髓在节点插入和节点删除的地方。考虑的比较全面，多多仔细推敲代码能收获不少。

coding__madman
关注
专栏目录
c语言求树上节点的双亲,树（Tree）
weixin_39756481的博客
05-19 918
本文主要是对数据结构中非线性结构 树 的学习和总结。树的定义专业定义：1.有且只有一个称为根的节点2.有若干个互不相交的子树，这些子树本身也是一棵树通俗的定义：1.树由节点和边组成2.每一个节点只有一个父节点但可以有多个子节点3.当有一个节点例外，该节点没有父节点，该节点称为根节点专业术语：节点 父节点 子节点 子孙 堂兄弟深度：从根节点到最底层节点的层数称之为深度。 根节点是第一层叶子...
看数据结构写代码（30） 树的双亲孩子表示法的实现
fuming0210sc的专栏
03-26 3993
树的 实现 方法 有三种：1.双亲 表示法  2. 孩子 表示 方法 3 结合 双亲 孩子 表示法 4. 二叉链表法 其中 前三种  都是 顺序 表示法， 都是 用 一组 顺序的 内存 空间 来表示 树。其中 在每个节点 上 加上 双亲 索引 位置的 叫做 双亲 表示法，在 每个节点上 加上 一个 孩子 链表的叫做 孩子 表示法。 这个链表 存储着  这个节点的 所有 子树 根 位置的 索引。把
二叉树的分支结点C语言,求一棵二叉树的深度和双分支结点的个数
weixin_30227565的博客
05-25 466
#includetypedef struct BiTNode{ /*数结构*/char data;struct BiTNode *lchild,*rchild;} BiTNode,*BiTree;BiTree CreateBiTree(){ /*递归建树*/char ch;BiTree T;scanf("%c",&ch);if(ch==' ')T=NULL;else{T=(BiTNod...
二叉树查找双亲结点
qq_43527713的博客
11-15 1万+
//递归实现查找双亲结点 void Find_Father(BiTNode *(&T),ElemType data) { if(T ==NULL) return; if(T->lchild != NULL)//当左孩子存在的时候才进行判断，否则程序出错 { if(T->lchild->data == data)...
先序输入构建将二叉树_并将二叉树转换为孩子兄弟双亲表示的一般树所构成的森林c语言实现
vivi_and_qiao的博客
01-09 2199
二叉树转换为森林的方法： （1）加线：若某结点是其双亲的左孩子，则把该节点的右孩子、右孩子的右孩子·····都与该结点的双亲结点间加上连线。 （2）删线：删掉原来二叉树中所有双亲结点与右孩子间的连线。 （3）旋转调整：旋转、整理由（1）（2）两步得到的各种树，使之结构清晰，层次分明。 又如图所示： C语言代码实现： 1.二叉树存储结构： ypedef struct binarytreenode ...
C语言通用范例开发金典.part1.rar
08-31
1.4.7 双亲、孩子和兄弟节点的查询（链式结构） 162 范例1-61 双亲、孩子和兄弟节点的查询 162 ∷相关函数：Parent函数 LeftChild函数 RightChild函数 LeftSibling函数 RightSibling函数 1.4.8 中序遍历二叉树...
C语言通用范例开发金典.part2.rar
08-31
1.4.7 双亲、孩子和兄弟节点的查询（链式结构） 162 范例1-61 双亲、孩子和兄弟节点的查询 162 ∷相关函数：Parent函数 LeftChild函数 RightChild函数 LeftSibling函数 RightSibling函数 1.4.8 中序遍历二叉树...
C/C++ - 数据结构（链表、栈、队列、树（二叉树））、动态数组
LawssssCat的博客
11-09 882
用递归 减少运行时间 通过递归，缩小问题的范围。O（logN） 不用递归 1.递归调用之后，实际上没有必要知道存在的值 比如： //(尾递归) 尾递归可以通过将代码放到一个while循环中并用每个方法参数的一次赋值代替递归调用而被手工能消除。 //(尾递归) public static <T> void printList(Iterator<T> itr){ if(!...
PTA数据结构期末练习-单选题
Gecko_F的博客
06-28 9913
数据结构练习题
数据结构（c语言版）代码
热门推荐
weixin_30814329的博客
01-07 3万+
第1章 绪论 文档中源码及测试数据存放目录：数据结构\▲课本算法实现\▲01 绪论 概述 第一章作为绪论，主要介绍了数据结构与算法中的一些基本概念和术语。对于这些概念术语，我个人不推崇死记硬背，记住了当然好，记不住也没关系，但是一定要做到完全理解。就算嘴上说不出来，心里也一定要明白这个过程的含义。 数据结构 数据(data)是对客观事物的符号表...
树的双亲表示法，孩子表示法，孩子兄弟表示法（C语言）
08-10 750
树的双亲表示法：使用顺序表 /*#include<stdio.h> #include<stdlib.h> //节点结构 typedef struct Node { char data; int parent; }Node...
二叉树如何实现双亲结点及求树的高度
钟真龙的博客
12-08 8049
求二叉树的高度，可以用递归的思想去求解，也可以用非递归的思想去求解，只不过，递归的代码简单明了，但是总的来说，递归有递归的好处，非递归当然也有非递归的好处。 求树的高度的递归思想和递归建树的思想差不多：                                                                 从最底层的子树（结点）开始，求每颗子树（个结点）的左子树和右子树
二叉树
weixin_46031570的博客
02-20 706
二叉树1.树的概念及结构2.二叉树的概念及结构2.1概念2.1.1特殊二叉树2.1.2二叉树的性质 1.树的概念及结构 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 有一个特殊的结点，称为根结点，根节点没有前驱结点 除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i<= m)又是一棵结构与树类似的子树。每棵子树的
孩子兄弟树详解（C语言版）
qq_44075108的博客
04-12 5330
孩子兄弟树详解（C语言版）
【二叉树】45 二叉树：结点个数
windyuan~
02-25 570
问题描述 : 内容：（1）请参照链表的ADT模板，设计二叉树并逐步完善的抽象数据类型。（由于该环境目前仅支持单文件的编译，故将所有内容都集中在一个源文件内。在实际的设计中，推荐将抽象类及对应的派生类分别放在单独的头文件中。参考教材、课件，以及网盘中的链表ADT原型文件，自行设计二叉树的ADT。） 注意：二叉树ADT的基本操作的算法设计很多要用到递归的程序设计方法。 （2）基本操作17：在二叉树的二叉链表存储形式建立的基础上，使用递归的程序设计方法，设计并完成统计结点个数的算法。完成后将其加入到二.
数据结构与算法-09（二叉树）
小北呱的博客
08-02 631
1.1树的基本定义 树是我们计算机中非常重要的一种数据结构，同时使用树这种数据结构，可以描述现实生活中的很多事物，例如家 谱、单位的组织架构、等等。 树是由n（n>=1）个有限结点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就 是说它是根朝上，而叶朝下的。 树具有以下特点： 1.每个结点有零个或多个子结点； 2.没有父结点的结点为根结点； 3.每一个非根结点只有一个父结点； ...
二叉树练习（二）：树的双亲表示法及其部分算法实现
Melonl的博客
10-09 5355
双亲表示法，即储存树结点的同时储存其所属的父结点的表示法，通常利用顺序表（数组）实现。
C++ 树、树的存储结构（双亲表示法，孩子表示法，双亲孩子表示法）
weixin_43975276的博客
08-18 3574
双亲表示法 双亲表示法的特点就是每一个节点里面除了存放节点数据之外，还存放着该节点的双亲节点位置。 #include<iostream> #define maxTree 100 using namespace std; typedef struct//双亲节点 { string data;//节点数据 int parent;//节点的双亲节点下标 }Pparent; typedef struct { Pparent nodes[maxTree];//节点数组 int r, n;//r代表
二叉树(1)——二叉树的定义和递归实现
专注于此刻
06-11 319
定义 最多有两棵子树的有序树，称为二叉树。二叉树是一种特殊的树。 递归定义：二叉树是n(n&gt;=0)个有限结点构成的集合。N=0称为空二叉树；n&gt;0的二叉树由一个根结点和两互不相交的，分别称为左子树和右子树的二叉树构成。 二叉树中任何结点的第1个子树称为其左子树，左子树的根称为该结点的左孩子；二叉树中任何结点的第2个子树称为其右子树，左子树的根称为该结点的右孩子。如下图是一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值