二叉树c语言实现 bittree.h 和 bittree.h

最新推荐文章于 2023-03-13 17:24:49 发布
最新推荐文章于 2023-03-13 17:24:49 发布
阅读量2.2k 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： c语言 二叉树 递归 遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chen1540524015/article/details/74887148
版权

bittree.h 文件

#ifndef _BIT_TREE_H_
#define _BIT_TREE_H_
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//树的定义是递归定义的，节点下面又拆分为左子树和右子树
//树是由节点组成，除了叶子节点，其他节点又是相对的根节点，
//相对的根节点下有相对的左右子树

//树的遍历的本质就是走一圈，每一个非叶子节点就是相对的根节点，都经过3次
//第一次访问为先序，第二次访问为中序，第三次访问为后序
#ifndef bool
#define bool int
#define true 1
#define false 0
#endif

//数的头首地址就可以用第一个节点的地址表示
typedef struct BitNode
{
    int data;
    struct BitNode *lchild,*rchild;
}BitNode,*BitTree;

#ifdef __cplusplus
extern "C"{
#endif

extern void preOrder(BitNode* root);
extern void midOrder(BitNode* root);
extern void lastOrder(BitNode* root);
extern void countLeafNodes(BitNode* root,int* sum);
extern int getDepth(BitNode* root);
extern BitNode* copyBitTree(BitNode* root);

#ifdef __cplusplus
}
#endif

#endif

bittree.c 文件

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "bittree.h"

//树的先序遍历。递归算法。
void preOrder(BitNode* root)
{
    if (root == NULL)
    {
        return;
    }
    //打印根节点的数据
    printf("先序遍历：%d \n",root->data);
    //遍历左子树
    if (root->lchild != NULL)
    {
        preOrder(root->lchild);
    }
    //遍历右子数
    if (root->rchild != NULL)
    {
        preOrder(root->rchild);
    }

}
//树的中序遍历。递归算法
void midOrder(BitNode* root)
{
    if (root == NULL)
    {
        return;
    }
    //遍历左子树
    if (root->lchild != NULL)
    {
        midOrder(root->lchild);
    }
    //打印根节点的数据
    printf("中序遍历：%d \n",root->data);
    //遍历右子数
    if (root->rchild != NULL)
    {
        midOrder(root->rchild);
    }
}
//树的后序遍历。递归算法
void lastOrder(BitNode* root)
{
    if (root == NULL)
    {
        return;
    }
    //遍历左子树
    if (root->lchild != NULL)
    {
        lastOrder(root->lchild);
    }
    //遍历右子数
    if (root->rchild != NULL)
    {
        lastOrder(root->rchild);
    }
    //打印根节点的数据
    printf("后序遍历：%d \n",root->data);
}

//统计叶子节点的个数，叶子节点就是没有孩子的节点。递归算法
void countLeafNodes(BitNode* root,int* sum)
{

    if (root)
    {
        //先统计传入节点有没有叶子节点
        if (root->lchild == NULL && root->rchild == NULL)
        {
            (*sum) = (*sum) + 1;
        }
        //统计传入节点左子树的叶子节点,存在左子树
        if (root->lchild)
        {
            countLeafNodes(root->lchild,sum);
        }

        //统计传入节点右子树的叶子节点，存在右子树
        if (root->rchild)
        {
            countLeafNodes(root->rchild,sum);
        }

    }
}

//求树的深度,递归算法
int getDepth(BitNode* root)
{
    int leftdepth ;
    int rightdepth ;
    int depth ;
    if (root == NULL)
    {
        return 0;
    }
    else
    {
        leftdepth = getDepth(root->lchild);   //左子树的深度
        rightdepth = getDepth(root->rchild);  //右子树的深度
        depth = 1 + (leftdepth > rightdepth ? leftdepth : rightdepth);  //左右子树最大深度加1（根节点）

    }
    return depth;
}
//copy树，递归
BitNode* copyBitTree(BitNode* root)
{
    BitNode* newNode = NULL;
    BitNode* newLeftChild = NULL;
    BitNode* newRightChild = NULL;
    if (root == NULL)
    {
        return NULL;
    }
    //copy左子树
    if (root->lchild != NULL)
    {
        newLeftChild = copyBitTree(root->lchild);
    }
    else newLeftChild = NULL;
    //copy右子树
    if (root->rchild != NULL)
    {
        newRightChild = copyBitTree(root->rchild);
    }
    else newRightChild = NULL;
    //为copy的节点分配内存
    newNode = (BitNode*)malloc(sizeof(BitNode));
    if (newNode == NULL)
    {
        return NULL;
    }
    //为copy的节点指针域赋值
    newNode->lchild = newLeftChild;
    newNode->rchild = newRightChild;
    //为copy的数据域赋值
    newNode->data = root->data;
    return newNode;
}
/***********************测试代码********************/

/*
void main()
{
    //BitNode t1;
    //memset(&t1,0,sizeof(BitNode));

    BitNode *t1,*t2,*t3,*t4,*t5;
    int sumleafnode = 0;
    int depth = 0;
    t1 = NULL;t2 = NULL; t3 = NULL; t4 = NULL; t5 = NULL;
    t1 = (BitNode *)malloc(sizeof(BitNode));
    t2 = (BitNode *)malloc(sizeof(BitNode));
    t3 = (BitNode *)malloc(sizeof(BitNode));
    t4 = (BitNode *)malloc(sizeof(BitNode));
    t5 = (BitNode *)malloc(sizeof(BitNode));
    memset(t1,0,sizeof(BitNode));
    memset(t2,0,sizeof(BitNode));
    memset(t3,0,sizeof(BitNode));
    memset(t4,0,sizeof(BitNode));
    memset(t5,0,sizeof(BitNode));
    t1->data = 1;
    t2->data = 2;
    t3->data = 3;
    t4->data = 4;
    t5->data = 5;

    t1->lchild = t2;
    t1->rchild = t3;
    t2->lchild = t4;
    t3->lchild = t5;

    preOrder(t1);
    midOrder(t1);
    lastOrder(t1);
    countLeafNodes(t1,&sumleafnode);
    printf("叶子的节点个数是：%d \n",sumleafnode);
    depth = getDepth(t1);
    printf("树的深度是：%d \n",depth);

    {
        BitNode* copytree = copyBitTree(t1);
        preOrder(copytree);
    }
    if (t1 != NULL)
    {
        free(t1);
        t1 = NULL;
    }
    if (t2 != NULL)
    {
        free(t2);
        t2 = NULL;
    }
    if (t3 != NULL)
    {
        free(t3);
        t3 = NULL;
    }
    if (t4 != NULL)
    {
        free(t4);
        t4 = NULL;
    }
    if (t5 != NULL)
    {
        free(t5);
        t5 = NULL;
    }
    system("pause");
}

*/
#include <iostream>
#include <stack>
#include "bittree.h"
using namespace std;
/********二叉树的中序非递归遍历，采用栈的方式*****************/
/*
步骤1：如果结点没有左子树，该结点入栈；
        如果结点没有左子树，访问该结点；
步骤2：如果结点有右子树，重复步骤1；
        如果结点没有右子树（结点访问完毕），
        根据栈顶指示回退，访问栈顶元素，
        并访问右子树，重复步骤1；如果栈为空，表示遍历完毕。
注意：入栈的结点表示，本身没有被访问过，同时右子树也没有被访问过。
*/
//一直往左走，找到中序遍历的起点
BitNode* goleft(BitNode* root, stack<BitNode*>& s)
{
    if (root == NULL)
    {
        return NULL;
    }
    //如果该结点有左子树，该结点入栈，指针下移
    while(root->lchild != NULL)
    {
        s.push(root);
        root = root->lchild;
    }
    //如果没有左子树，返回该结点 
    return root;
}
void stlmidOrder(BitNode* root)
{
    BitNode* t = NULL;
    stack<BitNode*> s;
    t  = goleft(root,s);
    while(t)
    {
        printf("中序非递归遍历：%d \n",t->data);

        //如果t有右子树，重复步骤1
        if (t->rchild != NULL)
        {
            t = goleft(t->rchild,s);//右子树中中序遍历起点
        }
        else if(!s.empty())  //如果t没有右子树，根据栈顶指示回退
        {
            t = s.top();
            s.pop();
        }
        else  //如果t没有右子树，并且栈为空
        {
            t = NULL;
        }

    }
}
void main()
{
    BitNode *t1,*t2,*t3,*t4,*t5;
    int sumleafnode = 0;
    int depth = 0;
    t1 = NULL;t2 = NULL; t3 = NULL; t4 = NULL; t5 = NULL;
    t1 = (BitNode *)malloc(sizeof(BitNode));
    t2 = (BitNode *)malloc(sizeof(BitNode));
    t3 = (BitNode *)malloc(sizeof(BitNode));
    t4 = (BitNode *)malloc(sizeof(BitNode));
    t5 = (BitNode *)malloc(sizeof(BitNode));
    memset(t1,0,sizeof(BitNode));
    memset(t2,0,sizeof(BitNode));
    memset(t3,0,sizeof(BitNode));
    memset(t4,0,sizeof(BitNode));
    memset(t5,0,sizeof(BitNode));
    t1->data = 1;
    t2->data = 2;
    t3->data = 3;
    t4->data = 4;
    t5->data = 5;

    t1->lchild = t2;
    t1->rchild = t3;
    t2->lchild = t4;
    t3->lchild = t5;

    //preOrder(t1);
    midOrder(t1);
    stlmidOrder(t1);
    //lastOrder(t1);
    countLeafNodes(t1,&sumleafnode);
    printf("叶子的节点个数是：%d \n",sumleafnode);
    depth = getDepth(t1);
    printf("树的深度是：%d \n",depth);

    {
        BitNode* copytree = copyBitTree(t1);
        preOrder(copytree);
    }
    if (t1 != NULL)
    {
        free(t1);
        t1 = NULL;
    }
    if (t2 != NULL)
    {
        free(t2);
        t2 = NULL;
    }
    if (t3 != NULL)
    {
        free(t3);
        t3 = NULL;
    }
    if (t4 != NULL)
    {
        free(t4);
        t4 = NULL;
    }
    if (t5 != NULL)
    {
        free(t5);
        t5 = NULL;
    }
    system("pause");
}

可能会调用其它头文件或源文件，如果调用，请翻看我的其它博客，对其头文件或源文件的实现方式。
good luck !

夏天不热 冬天不冷
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第九周项目一—二叉树算法库
wanghuahui1的博客
10-26 373
/* * Copyright (c) 2017,烟台大学计算机学院 * All right reserved. * 文件名称：main.cpp * 作者：王华慧 * 完成日期：2017年10月26日 * 版本号：v1.0 * * 问题描述：建
数据结构二叉树头文件BiTree.h
04-25
数据结构二叉树头文件BiTree.h
C语言二叉树代码实现
热门推荐
许新天的博客
07-14 3万+
btree.h  //二叉树头文件，用于声明数据类型和相关函数#ifndef __BTREE_H__ #define __BTREE_H__ #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;stdbool.h&gt; typedef char dataype_bt; //声明二叉树中存放的数据类型，便于后续更改 ...
第十周项目1-二叉树算法库
mlq9527的博客
11-03 232
/*    * Copyright (c) 2016, 烟台大学计算机与控制工程学院    * All rights reserved。    * 文件名称 ：1.cpp    * 作    者 ：孟令群    * 完成日期 ：2016年 11月3日    * 版 本 号 ：v1.0    * 问题描述 ：定义二叉树的链式存储结构，实现其基本运算  * 输入描述 ：  * 输出描
数据结构-树
Galaxy_z的博客
03-13 125
数据结构-树的详解
红黑二叉树C语言实现.cpp
03-29
红黑二叉树.cpp
数据结构之线索二叉树-C语言实现.pdf
最新发布
01-15
线索二叉树 数据结构学习笔记——线索二叉树
二叉树的实现c语言.md
03-17
c初学者，数据结构
C语言实现二叉树的基本操作源码.zip
10-30
二叉树
C语言平衡二叉树.zip
10-28
玩转二叉树
树之二叉树 图解和代码实现
ggxxkkll的专栏
03-12 2528
树之二叉树   图解：       以下是代码实现：   bitree.h   //声明类BiTree及定义结构BiNode,文件名为bitree.h #ifndef BITREE_H #define BITREE_H template struct BiNode //二叉树的结点结构 { T data; BiNode *lch
第五章 树和二叉树 实验
xiejunyong1124的专栏
11-30 857
实验目的      巩固树和二叉树的相关知识，特别是二叉树的相关内容。学会运用灵活应用。 1.回树和二叉树的逻辑结构和存储方法，清楚掌握树和二叉树的遍历操作。 2.学习树的相关知识来解决实际问题。 3.进一步巩固程序调试方法。 4.进一步巩固模板程序设计。 实验内容 1.自己设计一个二叉树，深度最少为4，请递归算法分别用前序、中序、后序遍历输出树结点。
二叉树的C++实现
Ajay666的博客
08-05 2万+
数据结构与二叉树类的定义我采用链式存储结构来表示二叉树，每一个二叉树节点包含树节点的值、树的左孩子指针、树的右孩子指针：class BiNode{ public: char data; struct BiNode *lchild,*rchild; };那么对于一个二叉树来说，只需要存放指向树根节点的指针即可，另外还需要声明二叉树的一些功能，比如遍历方法、求树高等（BiTree.h）：
tree.h
c_million的博客
09-30 887
/*二叉搜索树*/ /* 操作： */ /* 操作前： */ /* 操作后： */ #ifndef _TREE_H #define _TREE_H #include<stdbool.h>typedef struct item { char petname[20];/* 宠物名字*/ char petkind[20];/* 宠物种类*/ }Item;#define MAXITEMS 1
第十周--项目1-二叉树算法库
lct97的博客
11-02 271
问题描述及代码： #ifndef BTREE_H_INCLUDED #define BTREE_H_INCLUDED /* *烟台大学计控学院 *作 者：刘春彤 *完成日期：2016年11月2日 *问题描述：定义二叉树的链式存储结构，实现其基本运算，并完成测试。 要求： 　　1、头文件btree.h中定义数据结构并声明用于完成基本运算的函数。对应基
c语言二叉树的头文件叫什么,西安交大朱站立《数据结构——使用C语言》头文件系列——二叉树...
weixin_42531396的博客
05-23 984
西安交大朱站立《数据结构——使用C语言》各种头文件,顺序表、链表、堆栈、串、图等,有待更新,敬请期待!为了方便大家操作,此次存储为了word文档,更适合直接复制调用。本文为二叉链存储结构的二叉树操作实现，实现了二叉树的定义、插入数据、删除数据、撤销以及二叉树的打印、前序遍历、中序遍历、后序遍历等。本项目工程包含2个头文件(BiTree.h、BiTreeTraverse.h)和一个源文件(BiTre...
数据结构（C语言）中序线索二叉树
Yutouxn0的博客
12-02 982
#include"stdio.h" #include"stdlib.h" #define MAXNODE 1000 typedef int elemtype; //不带头结点的二叉中序线索链表 typedef struct bitnode { elemtype data; struct bitnode* lchild,* rchild; int ltag, rtag; }bitnode,*bittree; bitnode* createnode(elemtype data) { bitnode* .
数据结构学习之二叉树(实践篇)
落魄影子
01-17 1万+
注：本文的主要目的是为了记录自己的学习过程，也方便与大家做交流。转载请注明来自： http://blog.csdn.net/ab198604         上一篇博文主要对树、二叉树的概念及其一些基本特性进行简要的描述，偏向于理论知识。而本文的主要内容是针对二叉树这种数据结构的实现细节进行设计与分析，理论与实践相结合可以加深对系统知识的掌握。二叉树这种数据结构，应用非常广泛，在l
c语言二叉树的常用操作详解,数据结构.二叉树的基本操作(C语言实现)
weixin_33404792的博客
05-21 378
#include"bintree.h"#include#includevoid print(Item item){printf("%d ",item);}BiTree InitBiTree(BiTNode *root){BiTree tree = root;return tree;}BiTNode *MakeNode(Item item,BiTNode *lchild,BiTNode *rchil...
用c语言实现 1.先序遍历创建二叉树； 2.中序线索化二叉树； 3.分别通过 找前驱 和 找后继 的方式，遍历中序线索二叉树。
05-27
好的，以下是用C语言实现的代码： ```c #include<stdio.h> #include<stdlib.h> #include<stdbool.h> // 定义二叉树节点的结构体 struct TreeNode { char data; // 数据域 struct TreeNode* leftChild; // 左孩子指针 struct TreeNode* rightChild; // 右孩子指针 bool leftTag; // 左线索标志 bool rightTag; // 右线索标志 }; // 先序遍历创建二叉树 struct TreeNode* createBinaryTree() { char c; scanf("%c", &c); getchar(); // 读取输入字符后需要跳过回车符 if (c == '#') { // 如果输入#，表示该节点为空指针 return NULL; } struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode)); // 创建根节点 root->data = c; root->leftChild = createBinaryTree(); // 递归创建左子树 root->rightChild = createBinaryTree(); // 递归创建右子树 return root; } // 中序线索化二叉树 void inOrderThreading(struct TreeNode* root, struct TreeNode** pre) { if (root == NULL) { // 如果是空树，直接返回 return; } inOrderThreading(root->leftChild, pre); // 递归线索化左子树 if (root->leftChild == NULL) { // 如果左孩子为空，将左孩子指针指向前驱节点 root->leftChild = *pre; root->leftTag = true; } if (*pre != NULL && (*pre)->rightChild == NULL) { // 如果前驱节点的右孩子为空，将前驱节点的右孩子指针指向当前节点 (*pre)->rightChild = root; (*pre)->rightTag = true; } *pre = root; // 更新前驱节点 inOrderThreading(root->rightChild, pre); // 递归线索化右子树 } // 获取中序线索二叉树的第一个节点 struct TreeNode* firstNode(struct TreeNode* root) { while (root->leftTag == false) { root = root->leftChild; } return root; } // 获取中序线索二叉树中节点的后继节点 struct TreeNode* nextNode(struct TreeNode* root) { if (root->rightTag == false) { // 如果右线索标志为false，表示有右孩子 return firstNode(root->rightChild); } else { // 如果右线索标志为true，表示没有右孩子，返回右线索指向的后继节点 return root->rightChild; } } // 通过找前驱的方式遍历中序线索二叉树 void inOrderTraverseByPredecessor(struct TreeNode* root) { while (root != NULL) { while (root->leftTag == false) { // 如果左线索标志为false，说明有左孩子，继续向左走 root = root->leftChild; } printf("%c ", root->data); // 输出当前节点 root = root->leftChild; // 向左孩子继续遍历 } printf("\n"); } // 通过找后继的方式遍历中序线索二叉树 void inOrderTraverseBySuccessor(struct TreeNode* root) { struct TreeNode* p = firstNode(root); // 获取第一个节点 while (p != NULL) { printf("%c ", p->data); // 输出当前节点 p = nextNode(p); // 获取当前节点的后继节点 } printf("\n"); } int main() { struct TreeNode* root = createBinaryTree(); // 创建二叉树 struct TreeNode* pre = NULL; inOrderThreading(root, &pre); // 中序线索化二叉树 printf("通过找前驱的方式遍历中序线索二叉树："); inOrderTraverseByPredecessor(root); // 通过找前驱的方式遍历中序线索二叉树 printf("通过找后继的方式遍历中序线索二叉树："); inOrderTraverseBySuccessor(root); // 通过找后继的方式遍历中序线索二叉树 return 0; } ``` 以上代码中，`createBinaryTree`函数用于创建二叉树，`inOrderThreading`函数用于中序线索化二叉树，`firstNode`函数用于获取中序线索二叉树的第一个节点，`nextNode`函数用于获取中序线索二叉树中节点的后继节点，`inOrderTraverseByPredecessor`函数用于通过找前驱的方式遍历中序线索二叉树，`inOrderTraverseBySuccessor`函数用于通过找后继的方式遍历中序线索二叉树。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值