二叉树的基本操作

最新推荐文章于 2025-05-12 22:58:11 发布
原创 最新推荐文章于 2025-05-12 22:58:11 发布 · 344 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
数据结构

当前文章被收录于：

数据结构
26 篇文章 1 人学习
订阅专栏 查看详情
这篇博客介绍了二叉树的基本操作，包括创建和销毁节点、树的初始化、四种遍历方式（先序、中序、后序、层序），以及从数组构建树。此外，还讨论了树的深拷贝、节点计数、叶子节点计数、求某层节点数、树的高度计算、查找节点、获取节点的父、左右子节点等功能，并提供了测试和结果展示。
  • 创建树节点
TreeNode* CreateTreeNode(TreeNodeType value){
    TreeNode* new_node = (TreeNode*)malloc(sizeof(TreeNode));
    new_node->data = value;
    new_node->lchild = NULL;
    new_node->rchild = NULL;
    return new_node;
}
  • 销毁树节点
void DestroyTreeNode(TreeNode* node){
    free(node);
}
  • 树的初始化
void TreeInit(TreeNode** pRoot){
    if(pRoot == NULL){
        //非法输入
        return;
    }
    *pRoot = NULL;
    return;
}
  • 树的先序遍历（递归版本）
void TreePreOrder(TreeNode* root){
    if(root == NULL){
        printf("#");
        return;
    }
    //先访问根节点
    printf("%c",root->data);
    //递归遍历左子树
    TreePreOrder(root->lchild);
    //递归遍历右子树
    TreePreOrder(root->rchild);
    return;
}
  • 树的中序遍历（递归版本）
void TreeInOrder(TreeNode* root){
    if(root == NULL){
        return;
    }
    //先递归遍历左子树
    TreeInOrder(root->lchild);
    //访问根节点
    printf("%c ",root->data);
    //再递归遍历右子树
    TreeInOrder(root->rchild);
    return;
}
  • 树的后序遍历（递归版本）
void TreePostOrder(TreeNode* root){
    if(root == NULL){
        return;
    }
    //先递归遍历左子树
    TreePostOrder(root->lchild);
    //然后递归遍历右子树
    TreePostOrder(root->rchild);
    //访问根节点
    printf("%c ",root->data);
    return;
}
  • 树的层序遍历
void TreeLevelOrder(TreeNode* root){
    if(root == NULL){
        return;
    }
    //基于链表来操作
    SeqQueue queue;
    SeqQueueInit(&queue);
    SeqQueuePush(&queue,root);
    while(1){
        SeqQueueType front;
        int ret = SeqQueueFront(&queue,&front);
        if(ret == 0){
            //遍历结束
            break;
        }
        //打印当前值
        printf("%c ",front->data);
        //把当前队首元素出队列
        SeqQueuePop(&queue);
        //把当前元素的左右子树入队列
        if(front->lchild != NULL){
            SeqQueuePush(&queue,front->lchild);
        }
        if(front->rchild != NULL){
            SeqQueuePush(&queue,front->rchild);
        }
    }
    return;
}
  • 输入一个数组，根据数组内容构建一棵树，数组中的元素内容符合树的先序遍历结果（包含所有的空节点）
TreeNode* TreeCreate(TreeNodeType data[],size_t size,char null_node){
    size_t index = 0;
    //_TreeCreate为辅助递归函数
    return _TreeCreate(data,size,&index,null_node);
}

TreeNode* _TreeCreate(TreeNodeType data[],size_t size,size_t* index,TreeNodeType null_node){
    if(index == NULL){
        return NULL;
    }
    if(*index >= size){
        return NULL;
    }
    if(data[*index] == null_node){
        //空树
        return NULL;
    }
    //根据index指向的内容创建一个节点
    TreeNode* new_node = CreateTreeNode(data[*index]);
    //先++index，再递归构建新节点的左子树
    ++(*index);
    new_node->lchild = _TreeCreate(data,size,index,null_node);
    //再++index，递归构建新节点的右子树
    ++(*index);
    new_node->rchild = _TreeCreate(data,size,index,null_node);
    return new_node;
}
  • 树的拷贝（深拷贝）
TreeNode* TreeClone(TreeNode* root){
    if(root == NULL){
        return;
    }
    //按先序方式遍历
    TreeNode* new_node = CreateTreeNode(root->data);
    printf("%c ",new_node->data);
    new_node->lchild = TreeClone(root->lchild);
    new_node->rchild = TreeClone(root->rchild);
    return new_node;
}
  • 树的销毁
void TreeDestroy1(TreeNode** root){//使用后序遍历的顺序销毁
    if(root == NULL)
        return;
    if(*root == NULL)
        return;
    TreeDestroy1(&((*root)->lchild));
    TreeDestroy1(&((*root)->rchild));
    DestroyTreeNode(*root);
    *root = NULL;
}
void TreeDestroy2(TreeNode** root){//使用先序遍历的顺序销毁
    if(root == NULL)
        return;
    if(*root == NULL)
        return;
    TreeNode* lchild = (*root)->lchild;
    TreeNode* rchild = (*root)->rchild;
    DestroyTreeNode(*root);
    TreeDestroy2(&lchild);
    TreeDestroy2(&rchild);
    *root = NULL;
}
  • 求树的节点个数
size_t TreeSize1(TreeNode* root){
    if(root == NULL)
        return 0;
    size_t size = 0;
    _TreeSize(root,&size);
    return size;
}

void _TreeSize(TreeNode* root,size_t* size){
    if(root == NULL || size == NULL)
        return;
    ++(*size);
    _TreeSize(root->lchild,size);
    _TreeSize(root->rchild,size);
}
size_t TreeSize2(TreeNode* root){
    if(root == NULL)
        return 0;
    return 1+TreeSize2(root->lchild)+TreeSize2(root->rchild);
}
  • 求叶子节点的个数
size_t TreeLeafSize(TreeNode* root){
    if(root == NULL)
        return 0;
    if(root->lchild == NULL && root->rchild == NULL)
        return 1;
    return TreeLeafSize(root->lchild)+TreeLeafSize(root->rchild);
}
  • 求第K层的节点个数
size_t TreeKLevelSize(TreeNode* root,int K){
    if(root == NULL || K < 1)
        return 0;
    if(K == 1)
        return 1;
    return TreeKLevelSize(root->lchild,K-1)+TreeKLevelSize(root->rchild,K-1);
}
  • 求二叉树的高度/深度/层数
size_t TreeHeight(TreeNode* root){
    if(root == NULL)
        return;
    if(root->lchild == NULL && root->rchild == NULL)
        return 1;
    size_t lheight = TreeHeight(root->lchild);
    size_t rheight = TreeHeight(root->rchild);
    return 1+(lheight > rheight ? lheight : rheight);
}
  • 在二叉树中查找节点，给定一个值，求对应结点的指针（二叉树的节点不重复）
TreeNode* TreeFind(TreeNode* root,TreeNodeType to_find){
    if(root == NULL)
        return NULL;
    if(root->data == to_find)
        return root;
    TreeNode* lresult = TreeFind(root->lchild,to_find);
    TreeNode* rresult = TreeFind(root->rchild,to_find);
    return lresult != NULL ? lresult : rresult;
}
  • 求当前节点的父节点
TreeNode* Parent(TreeNode* root,TreeNode* child){
    if(root == NULL || child == NULL)
        return NULL;
    if(root->lchild == child || root->rchild == child)
        return root;
    TreeNode* lresult = Parent(root->lchild,child);
    TreeNode* rresult = Parent(root->rchild,child);
    return lresult != NULL ? lresult : rresult;
}
  • 求当前节点的左子树
TreeNode* LChild(TreeNode* node){
    if(node == NULL)
        return NULL;
    return node->lchild;
}
  • 求当前节点的右子树
TreeNode* RChild(TreeNode* node){
    if(node == NULL)
        return NULL;
    return node->rchild;
}


测试函数：

#include"bin_tree.h"
#define PRINT_HEAD printf("\n============%s============\n",__FUNCTION__);

void TestInit(){
    PRINT_HEAD;
    TreeNode* root;
    TreeInit(&root);
    printf("root expect NULL,actual %p\n",root);
    return;
}

void TestPreOrder(){
    PRINT_HEAD;
    TreeNode* root;
    TreeInit(&root);
    TreeNode* a = CreateTreeNode('a');
    TreeNode* b = CreateTreeNode('b');
    TreeNode* c = CreateTreeNode('c');
    TreeNode* d = CreateTreeNode('d');
    TreeNode* e = CreateTreeNode('e');
    TreeNode* f = CreateTreeNode('f');
    TreeNode* g = CreateTreeNode('g');
    a->lchild = b;
    a->rchild = c;
    b->lchild = d;
    b->rchild = e;
    e->lchild = g;
    c->rchild = f;
    printf("前序遍历为：");
    TreePreOrder(a);
    printf("\n");
}

void TestInOrder(){
    PRINT_HEAD;
    TreeNode* root;
    TreeInit(&root);
    TreeNode* a = CreateTreeNode('a');
    TreeNode* b = CreateTreeNode('b');
    TreeNode* c = CreateTreeNode('c');
    TreeNode* d = CreateTreeNode('d');
    TreeNode* e = CreateTreeNode('e');
    TreeNode* f = CreateTreeNode('f');
    TreeNode* g = CreateTreeNode('g');
    a->lchild = b;
    a->rchild = c;
    b->lchild = d;
    b->rchild = e;
    e->lchild = g;
    c->rchild = f;
    printf("中序遍历为：");
    TreeInOrder(a);
    printf("\n"); 
}

void TestPostOrder(){
    PRINT_HEAD;
    TreeNode* root;
    TreeInit(&root);
    TreeNode* a = CreateTreeNode('a');
    TreeNode* b = CreateTreeNode('b');
    TreeNode* c = CreateTreeNode('c');
    TreeNode* d = CreateTreeNode('d');
    TreeNode* e = CreateTreeNode('e');
    TreeNode* f = CreateTreeNode('f');
    TreeNode* g = CreateTreeNode('g');
    a->lchild = b;
    a->rchild = c;
    b->lchild = d;
    b->rchild = e;
    e->lchild = g;
    c->rchild = f;
    printf("后序遍历为：");
    TreePostOrder(a);
    printf("\n");
}

void TestLevelOrder(){
    PRINT_HEAD;
    TreeNode* root;
    TreeInit(&root);
    TreeNode* a = CreateTreeNode('a');
    TreeNode* b = CreateTreeNode('b');
    TreeNode* c = CreateTreeNode('c');
    TreeNode* d = CreateTreeNode('d');
    TreeNode* e = CreateTreeNode('e');
    TreeNode* f = CreateTreeNode('f');
    TreeNode* g = CreateTreeNode('g');
    a->lchild = b;
    a->rchild = c;
    b->lchild = d;
    b->rchild = e;
    e->lchild = g;
    c->rchild = f;
    printf("层序遍历为：");
    TreeLevelOrder(a);
    printf("\n");
}

void TestCreate(){
    PRINT_HEAD;
    TreeNodeType data[] = "abd##eg###c#f##";
    TreeNode* root = TreeCreate(data,sizeof(data)/sizeof(data[0])-1,'#');
    printf("\n先序遍历为：");
    TreePreOrder(root);
    printf("\n中序遍历为：");
    TreeInOrder(root);
    printf("\n后序遍历为：");
    TreePostOrder(root);
    printf("\n层序遍历为：");
    TreeLevelOrder(root);
    printf("\n");
}

void TestClone(){
    PRINT_HEAD; 
    TreeNodeType data[] = "abd##eg###c#f##";
    TreeNode* root = TreeCreate(data,sizeof(data)/sizeof(data[0])-1,'#');
    printf("先序遍历为：");
    TreeClone(root);
    printf("\n");
}

void TestDestroy1(){
    PRINT_HEAD; 
    TreeNodeType data[] = "abd##eg###c#f##";
    TreeNode* root = TreeCreate(data,sizeof(data)/sizeof(data[0])-1,'#');
    TreeDestroy1(&root);
    printf("root expect NULL,actaul %p\n",root);
}

void TestDestroy2(){
    PRINT_HEAD;
    TreeNodeType data[] = "abd##eg###c#f##";
    TreeNode* root = TreeCreate(data,sizeof(data)/sizeof(data[0])-1,'#');
    TreeDestroy2(&root);
    printf("root expect NULL,actaul %p\n",root); 
}

void TestSize(){
     PRINT_HEAD;  
     TreeNodeType data[] = "abd##eg###c#f##";
     TreeNode* root = TreeCreate(data,sizeof(data)/sizeof(data[0])-1,'#');
     size_t size1 = TreeSize1(root);
     printf("size1 expect 7,actual %lu\n",size1);
     size_t size2 = TreeSize2(root);                                                                                                                                                      
     printf("size2 expect 7,actual %lu\n",size2);
}

void TestLeafSize(){
    PRINT_HEAD;
    TreeNodeType data[] = "abd##eg###c#f##";
    TreeNode* root = TreeCreate(data,sizeof(data)/sizeof(data[0])-1,'#');
    size_t size = TreeLeafSize(root);
    printf("size expect 3,actual %lu\n",size);
}

void TestLevelSize(){
     PRINT_HEAD;
     TreeNodeType data[] = "abd##eg###c#f##";                                                                                                                                             
     TreeNode* root = TreeCreate(data,sizeof(data)/sizeof(data[0])-1,'#');
     size_t size = TreeKLevelSize(root,3);
     printf("size expect 3,actual %lu\n",size);
}

void TestHeight(){
     PRINT_HEAD;
     TreeNodeType data[] = "abd##eg###c#f##";                                                                                                                                             
     TreeNode* root = TreeCreate(data,sizeof(data)/sizeof(data[0])-1,'#');
     size_t size = TreeHeight(root);
     printf("size expect 4,actual %lu\n",size);
}

void TestFind(){
     PRINT_HEAD;
     TreeNodeType data[] = "abd##eg###c#f##";                                                                                                                                             
     TreeNode* root = TreeCreate(data,sizeof(data)/sizeof(data[0])-1,'#');
     TreeNode* result = TreeFind(root,'f');
     printf("result expect %p,actual %p\n",root->rchild->rchild,result);
}

void TestParent(){
    PRINT_HEAD;
    TreeNodeType data[] = "abd##eg###c#f##";   
    TreeNode* root = TreeCreate(data,sizeof(data)/sizeof(data[0])-1,'#');
    TreeNode* result = Parent(root,root->rchild->rchild);
    printf("result expect %c,actual %c\n",root->rchild->data,result->data);
}

void TestLChild(){
    PRINT_HEAD;
    TreeNodeType data[] = "abd##eg###c#f##";   
    TreeNode* root = TreeCreate(data,sizeof(data)/sizeof(data[0])-1,'#');
    TreeNode* result = LChild(root->lchild);
    printf("result expect %c,actual %c\n",root->lchild->lchild->data,result->data);
}

void TestRChild(){
    PRINT_HEAD;
    TreeNodeType data[] = "abd##eg###c#f##";   
    TreeNode* root = TreeCreate(data,sizeof(data)/sizeof(data[0])-1,'#');
    TreeNode* result = RChild(root->lchild);
    printf("result expect %c,actual %c\n",root->lchild->rchild->data,result->data);
}

int main(){
    TestInit();
    TestPreOrder();
    TestInOrder();
    TestPostOrder();
    TestLevelOrder();
    TestCreate();
    TestClone();
    TestDestroy1();
    TestDestroy2();
    TestSize();
    TestLeafSize();
    TestLevelSize();
    TestHeight();
    TestFind();
    TestParent();
    TestLChild();
    TestRChild();
}

结果演示：

















二叉树的建立与基本操作
01-29
编写程序实现二叉树的如下操作： 1) 建立二叉链表 2) 二叉树的先序、中序、后序遍历 3) 求解二叉树的叶子结点个数 4) 将二叉树中所有结点的左、右子树相互交换 输入： 　　扩展二叉树先序序列：ab#d##ce###。其中#代表空指针。 输出： 　　二叉树的凹入表示 　　二叉树的先序序列、中序序列、后序序列 　　二叉树叶子结点个数 　　左、右子树相互交换后的二叉树的凹入表示 　　左、右子树相互交换后的二叉树的先序序列、中序序列、后序序列。 说明： 　　在输出凹入表示的二叉树时，先输出根结点，然后依次输出左右子树，上下层结点之间相隔 3 个空格。
二叉树基本操作
04-30
以二叉链表作存储结构，编写程序，实现如下的功能： 1、根据输入的数据建立一个二叉树； 2、分别采用前序、中序、后序的遍历方式显示输出二叉树的遍历结果 3、采用非递归的编程方法，分别统计二叉树的节点个数、度为1、度为2和叶子节点的个数，以及数据值的最大值和最小值。 4、（选作内容）试编写按层次顺序遍历二叉树的算法。参考算法思想：要采用一个队列q，先将二叉树根结点入队列，然后退队列，输出该结点；若它有左子树，便将左子树根结点入队列；若它有右子树，便将右子树根结点入队列，直到队列空为止。因为队列的特点是先进先出，从而达到按层次顺序遍历二叉树的目的。
寒假数据结构学习Day15
2302_81247743的博客
02-19 1608
这里注意遍历的时候不能用中序遍历，中序会将同一个孩子交换俩遍。翻转二叉树的具体代码的实现。首先的得会自己创建二叉树。前序和后序以及层序都行。关于二叉树的一些知识。
二叉树（三）
Mr.Li的博客
12-01 220
求二叉树中两个节点的最近公共祖先节点 思路1： 如果两个节点在左右子树，最近的就是他们的根结点 两个节点在同一侧，用子问题方法求解 BTreeNode * Find(BTreeNode *root, TDataType data) { if(root == NULL) { return NULL; } if(root-&gt;data ...
二叉树的递归版实现
qq_40736410的博客
05-20 256
tree.h#pragma once#include&lt;stdlib.h&gt;#include&lt;stddef.h&gt;#include&lt;string.h&gt;#define TEST_HEAND printf("========%s=========\n",__FUNCTION__);typedef  char TreeNodeType;typedef  char SeqQu...
CS50 第五周 Data Structures
Anxonz的博客
11-04 252
三种可能的等位基因是 A、B 和 O，每个人都有两个（可能相同，也可能不同）。每个孩子的父母会随机地将自己的两个血型等位基因之一传递给他们的孩子。因此，可能的血型组合有：OO、OA、OB、AO、AA、AB、BO、BA 和 BB。例如，如果一个父亲的血型是AO，另一个父亲的血型是BB，那么孩子的可能血型将是AB和OB，具体取决于从每个父亲那里接收了哪个等位基因。同样，如果一个父亲的血型是AO，另一个父亲的血型是OB，那么孩子的可能血型将是AO、OB、AB 和 OO。
#方法创建二叉树
Hello，小高同学
09-10 1509
以下给出先序遍历的结果来创建二叉树，#方法可以唯一创建一颗二叉树，因为规定叶子节点后面必须要#来标识结束，所以，不管左子树和右子树如果没有，就肯定会有#,下面的例子可知，1是根，2是1的左子树，4是2的左子树，4为叶子节点，2的右子树为空，到此处就知道2这棵树结束，3为1的右子树，3为叶子节点。所以可以唯一确定这棵树。这种方法还是可以用在简单开发里面的。 （此图来源于传智播客课程） #defi...
二叉树的类型定义与基本操作
qq_45801780的博客
10-29 5460
二叉树的类型定义与基本操作 树结构是一类重要的非线性数据结构，在客观世界中广泛存在。树在计算机领域中也得到了广泛的应用，尤以二叉树最为常用。本文重点讨论二叉树的基本操作。 1. 二叉树的类型定义 二叉树通常由三个域组成：数据域、左孩子指针域和右孩子指针域。 其类型定义为： typedef struct BiNode { char data; // 数据域 struct BiNode* lchild, * rchild; // 左右孩子指针域 }Bi
C++ 二叉树的基本操作
nichengwuxiao的博客
12-22 1万+
一：目的 用C++实现二叉树的基本操作，建立和遍历； 二：介绍 在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 二叉树的遍历方式有三种，前序遍历，中序遍历，后序遍历。 它的前序遍历顺序为：ABDGHCEIF（规则是先是
【数据结构】二叉树的存储与基本操作的实现
m0_71731682的博客
08-30 4181
二叉树的存储结构分为：顺序存储和类似于链表的链式存储这里博主讲一下链式存储二叉树的链式存储是通过一个一个的节点引用起来的，常见的表示方式有二叉和三叉表示方式二叉表示： 三叉表示： 这里博主主要讲解一下孩子表示法在学习二叉树的基本操作前，需先要创建一棵二叉树，然后才能学习其相关的基本操作。由于现在大家对二叉树结构掌握还不够深入，为了降低大家学习成本，此处手动快速创建一棵简单的二叉树。 创建如下： 注意：上述代码并不是创建二叉树的方式，真正创建二叉树方式后序详解重点讲解在我们对二叉树进行基本操作之前，我们的先来
实验五 二叉树基本操作的编程实现
Htw18705081160的博客
04-13 1573
二叉树基本操作的编程实现（2学时，验证型），掌握二叉树的建立、遍历、插入、删除等基本操作的编程实现，也可以进一步编程实现查找等操作，存储结构主要采用顺序或链接结构。二叉树由根节点、左子树和右子树组成，而左子树和右子树也是一棵二叉树，它们的定义与原二叉树的定义相同，因此可以使用递归的方式来定义二叉树。=',') //输入数据不为逗号,表示不为虚结点,否则为虚结点。case 3:printf("二叉树中序遍历结果为：\n");case 4:printf("二叉树后序遍历结果为：\n");
二叉树的基本操作　C++代码实现
热门推荐
Tanswer_
10-29 1万+
首先定义节点typedef struct BTree { int value; struct BTree *lchild; struct BTree *rchild; }BTree;前序递归建立二叉树/* **num 前序序列 **index 下标 */ BTree *CreateBTree(BTree *node,int *num,int& index) {
【数据结构】实现二叉树的基本操作
qq_53869058的博客
03-26 4769
二叉树的前序、中序、后序以及层序遍历，获取节点个数，判断是否为完全二叉树等~
四、二叉树基本操作
kt_su的博客
09-06 634
有一个特殊的节点：根节点，根节点没有前驱节点。除根节点外，其余节点被分成 M（M > 0）个互不相交的集合，其中每一个集合又是一颗与树类似的子树。树是递归定义的。
Java 实现二叉树的基本操作
最新发布
LL_break的博客
05-12 1017
聚焦二叉树基本操作，包括获取节点数、叶子节点数、第K层节点数、树的深度、检测特定值是否存在以及判断是否为完全二叉树。代码，图解相结合帮助理解 整条街都是恋爱的人    我独自走在暖风的夜 ——寂寞的季节 DT
实验四 二叉树的基本操作
a1799069885的博客
05-20 8401
实验四 二叉树的基本操作 一、实验目的 1．掌握二叉树的定义； 2．掌握二叉树的基本操作，如二叉树的建立、遍历、结点个数统计、树的深度等。 二、实验内容 用递归的方法实现以下算法： 1．以二叉链表表示二叉树，建立一棵二叉树（算法5.3）； 2．输出二叉树的中序遍历结果（算法5.1或讲稿）； 3．输出二叉树的前序遍历结果（见讲稿）； 4．输出二叉树的后序遍历结果（见讲稿）； 5．计算二叉树的深度（算法5.5）； 6．统计二叉树的结点个数（算法5.6）. 三、实验环境 Dev C++
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值