(c语言实现)二叉树的相关操作 (二) 二叉树节点操作

本文链接：https://blog.csdn.net/kwinway/article/details/80147892

本文探讨了二叉树节点的各种操作，包括求解某层节点数、树高度、叶子节点个数、找父节点、镜像翻转、完全二叉树判断以及节点查找。内容涵盖递归和非递归方法，并提供了详细代码和测试。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

本文所指二叉树皆为普通二叉树,下同

二叉树的定义

在介绍相关操作时,请记住一点,
二叉树构建核心思想是递归,

typedef char treeNodeType;
typedef struct _treeNode{
    struct _treeNode* left;
    struct _treeNode* right;
    treeNodeType value;
}treeNode;

相关操作有:

1 二叉树的先序,中序,后续遍历的递归版,使用栈循环版,还有使用队列层序遍历版
2 求二叉树某层的节点数,求二叉树的总节点数,求二叉树叶子节点数,
3 求某节点的左右子节点或者父节点
3 将二叉树镜像翻转
4 判断一颗二叉树是否是完全二叉树
5 在二叉树中查找某节点
6 二叉树的深拷贝(clone)
7通过前序有标记空节点结果构建二叉树
8 通过前序中序遍历构建二叉树

这篇博客主要解决加粗部分,详细代码请参见
其中有完整头文件,源文件,和单元测试.
感谢!
剩余操作请参见
(c语言实现)二叉树的相关操作 (一) 二叉树的递归遍历和循环遍历

(c语言实现)二叉树的相关操作 (三) 通过遍历构建二叉树的两种类型

二叉树节点的计算

求二叉树某层节点数

在求某层节点时,首先需要遍历所有树,这里采用先序遍历,
在遍历时,创建一个标记变量,记录当前二叉树的深度,
当深度等于要求的层数而且节点非空时返回1;
并且递归的求解某节点左子树和右子树满足条件的节点

size_t TreeKLevelSize(treeNode* root, int k)
{
    if( root == NULL || k ==  0)
     return -1;
    int  count = 1;
    return _TreeKLevelSize(root,k,count);
}
size_t _TreeKLevelSize(treeNode* root,int k,int deep_count)
{
  if(root == NULL || deep_count > k)
        return 0;
    if(k == deep_count)
        return 1;
   return _TreeKLevelSize(root->left,k,deep_count + 1) 
   + _TreeKLevelSize(root->right,k,deep_count + 1);
}

求树的高度

对于一棵树,它的高度等于左子树的高度和右子树高度中最高的那一个,
所以我们可以递归的求解左子树和右子树中最高的那一个

size_t TreeHeight(treeNode* root)
{
   if(root == NULL)
       return 0;
   int left_count = 1 + TreeHeight(root->left);
   int right_count = 1 + TreeHeight(root->right);
   return left_count > right_count ? left_count : right_count;
}

求二叉树叶子节点的个数

递归的求左子树和右子树的叶子节点
若碰到空节点(NULL) return 0 返回
当节点的左右节点都为空时表示找到了叶子节点,return 1

size_t TreeLeafSize(treeNode* root)
{
    if(root == NULL)
        return 0;
    if(root->left == NULL && root->right == NULL)
        return 1;
    else
        //递归求树左子树和右子树中 叶子节点
        return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}

求二叉树的父节点

从根节点开始递归遍历
若A节点的左子节点或者右子节点等于被检索的节点,那么返回A节点
若没有找到则返回NULL
注意我们在每次递归的栈帧中都开辟了一个 parent_node 的变量来保存已经找到的父节点
用来向上级调用函数返回结果

treeNode* Parent(treeNode* root, treeNode* node)
{
    if(root == NULL || node == NULL)
        return NULL;
    treeNode* Parent_Node = NULL;
    if(root->left == node || root->right == node)
        return root;
    Parent_Node = Parent(root->left, node);
    //当在左子树中没有找到时,才在右子树中找
    if(Parent_Node == NULL)
        Parent_Node = Parent(root->right, node);
    return Parent_Node;
}

二叉树的镜像翻转

将

     4
   /   \
  2     7
 / \   / \
1   3 6   9

翻转为

     4
   /   \
  7     2
 / \   / \
9   6 3   1

我们可以遍历二叉树,只要它不是NULL,就把它的子节点交换,
当遍历结束时就将整个二叉树翻转完毕了,这里采用先序遍历

void TreeMirror(treeNode* root)
{
    if( root == NULL )
        return;
    treeNode* tmp = root->left;
    root->left = root->right;
    root->right = tmp;
    TreeMirror(root->left);
    TreeMirror(root->right);
}

据说homebrew的作者(一位大牛) 在面试谷歌时因为在白板上做不出来这道题而被谷歌拒绝了..
当你会了道题, 可以get到Google的offer了哈哈哈哈哈

判断二叉树是否是完全二叉树

完全二叉树(Complete Binary Tree)
若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。

我们可以用反证法判定二叉树
1 当一个节点有右子树而没有左子树时,肯定不是完全二叉树
这里写图片描述
2 当一个节点只有左子树时,该节点以后都必须是叶子节点,以下不是完全二叉树

这里写图片描述
3. 当出现叶子叶子节点时,该节点往后都必须是叶子节点,以下不是完全二叉树

我们可以通过层续遍历,来遍历这个树,
并且设置两个标记
SingleChild_flag 标记已经到度为1的情况
ReachLeaf_flag 标记到达叶子节点

int IsCompleteTree(treeNode* root)
{
    if(root == NULL)
        return -1;
    int SingleChild_flag = 0;
    int ReachLeaf_flag = 0;
    queue q;
    queueInit(&q);
    queuePush(&q,root);
    while(queueHead(&q) != NULL)
    {
        if( ReachLeaf_flag == 1  )
        {
                //到达叶子节点,但是以后节点不是叶子节点
            if(queueHead(&q)->left != NULL || queueHead(&q)-> right != NULL)
                return 0;
        }
        if(SingleChild_flag == 1)
        {
                  //到达度为1的节点,以后的节点不是叶子节点
            if(queueHead(&q)->right != NULL || queueHead(&q)->left != NULL)
                return 0;
        }
        //只有右节点
       if(queueHead(&q)->right != NULL && queueHead(&q)->left == NULL)
           return 0;
       //只有左节点
       else if( queueHead(&q)->left != NULL && queueHead(&q)->right == NULL )
       {
            //从该节点以后的节点必须是叶子节点
           SingleChild_flag = 1;
           ReachLeaf_flag = 1;
           queuePush(&q,queueHead(&q)->left);
           queueFront(&q,NULL);
           continue;
       }
       //叶子节点
       else if(queueHead(&q)->right == NULL && queueHead(&q)->left == NULL)
       {
           ReachLeaf_flag = 1;
           queueFront(&q,NULL);
           continue;
       }
       //有左右节点
       else
       {
           queuePush(&q,queueHead(&q)->left);
           queuePush(&q,queueHead(&q)->right);
           queueFront(&q,NULL);
       }
    }
    return 1;
}

在二叉树中查找某节点

因为是普通二叉树,所以还得遍历查找,时间复杂度为o(n),当遇到目标则返回
若查找不到返回NULL

treeNode* TreeFind(treeNode* root, treeNodeType to_find)
{
    treeNode* node = _TreeFind(root, to_find);
    return node;
}
treeNode* _TreeFind(treeNode* root, treeNodeType to_find)
{
    treeNode* to_ret = NULL;
    if(root == NULL)
        return NULL;
    if(root->value == to_find)
        return root;
    to_ret = _TreeFind(root->left, to_find);
    if(to_ret == NULL)
        to_ret = _TreeFind(root->right, to_find);
    return to_ret;
}