C语言写二叉树

已于 2023-09-14 09:02:21 修改
阅读量1.6k 收藏 25
点赞数 3
分类专栏： C语言学习 文章标签： c语言 数据结构 算法
于 2022-11-28 11:52:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51447496/article/details/128076676
版权

C语言写二叉树

简介：本文是博主当初学习阶段，用C语言实现的二叉树代码。

结点类（TNode.h）

#ifndef _TNode_h_
#define _TNode_h_

// 定义二叉树结点类型
typedef struct _TNODE_
{
    // 数据域
    char data;
    // 指针域(左、右孩子指针)
    struct _TNODE_ *lch, *rch;
} TNODE;

#endif

二叉树类（BinTree.h）

#ifndef _BinTree_h_
#define _BinTree_h_

#include "TNode.h"
// 创建二叉树
void BinTreeCreate(TNODE **root); 

// 创建二叉树
void BinTreeClear(TNODE **root);

// 销毁二叉树
void BinTreeDestroy(TNODE **root);

// 输入二叉树
void BinTreeInput(TNODE **root);

// 先序遍历
void BinTreePreorder(const TNODE *root);

// 后序遍历
void BinTreePostorder(const TNODE *root);

// 中序遍历
void BinTreeInorder(const TNODE *root);

// 输出二叉树
void BinTreeOutput(const TNODE *root);

// 求结点数
int BinTreeNumNode(const TNODE *root);

// 叶子结点数
int BinTreeNumLeaf(const TNODE *root);

// 分枝结点数
int BinTreeNumBranch(const TNODE *root);

// 二叉树的深度
int BinTreeDepth(const TNODE *root);

#endif

BinTree.c

创建二叉树

// 创建二叉树 
void BinTreeCreate(TNODE **root) // 之所以要用二级指针 是因为会有更改一级指针的操作 
{
	*root = NULL; 
}

清空二叉树

// 清空二叉树
void BinTreeClear(TNODE **root)
{
	if (*root) 
	{
		BinTreeClear(&(*root)->lch); // 这里要注意的是传入的是(*root)->lch的地址，这样才是一个二级地址 
		BinTreeClear(&(*root)->rch); // 这个是先释放左孩子，在释放右孩子 
		free(*root);
		*root = NULL;
	}
}

销毁二叉树

// 销毁二叉树
void BinTreeDestroy(TNODE **root)
{
	BinTreeClear(root); 		// 注意传的是二级指针 
}

输入二叉树


void BinTreeInput(TNODE **root)
{
//     if (*root != NULL && tag == 0)
//     {
//         BinTreeClear(root);
//     }

    tag = 1;
    char element;

    scanf (" %c", &element);
    if (element == '#')
    {
        *root = NULL; 
    }
    else
    {
        *root = (TNODE *)malloc(sizeof(TNODE));
        (*root)->data = element;
        BinTreeInput(&(*root)->lch);
        BinTreeInput(&(*root)->rch);
    }    
}

先序遍历

// 先序遍历
void BinTreePreorder(const TNODE *root)
{
	if (root)
	{
		printf("%c", root->data);
		BinTreePreorder(root->lch);
		BinTreePreorder(root->rch);
	}
}

后序遍历

// 后序遍历
void BinTreePostorder(const TNODE *root)
{
	if (root)
	{		
		BinTreePostorder(root->lch);
		BinTreePostorder(root->rch);
		printf("%c", root->data);
	}
}

中序遍历

// 中序遍历
void BinTreeInorder(const TNODE *root)
{
	if (root)
	{		
		BinTreeInorder(root->lch);
		printf("%c", root->data);
		BinTreeInorder(root->rch);		
	}
}

输出二叉树

static void BinTreeOutput1(const TNODE *root, int layer)
{
    if (root)
    {
        BinTreeOutput1(root->rch, layer + 1);
        for (int k = 1; k < layer; ++k)
        {
            printf("  ");
        }
        printf("%c\n", root->data);
        BinTreeOutput1(root->lch, layer + 1);
    }
}

void BinTreeOutput(const TNODE *root)
{
    BinTreeOutput1(root, 1);
}

求结点数

// 结点数
int BinTreeNumNode(const TNODE *root)
{
	int num;
	if (root)
	{
		num = 1 + BinTreeNumNode(root->lch) + BinTreeNumNode(root->rch);
	}
	else
	{
		num = 0;
	}
	return num;
}

叶子结点数

// 叶子结点数
int BinTreeNumLeaf(const TNODE *root)
{
	int num;
	if (root)
	{
		if (root->lch == NULL && root->rch == NULL)
		{
			num = 1;
		}
		else
		{
			num = BinTreeNumLeaf(root->lch) + BinTreeNumLeaf(root->rch);
		}
	}
	else
	{
		num = 0;		
	}
	return num;
}

分枝结点数

// 分枝结点数
int BinTreeNumBranch(const TNODE *root)
{
	int num = 0;
	if (root)
	{
		if (root->lch != NULL || root->rch != NULL)
		{
			num = 1;
		}		
				
		num += BinTreeNumBranch(root->lch) + BinTreeNumBranch(root->rch);		
	}
	else
	{
		num = 0;		
	}
	return num;
}

二叉树的深度

// 深度
int BinTreeDepth(const TNODE *root)
{
	int l, r;
	if (root == NULL)
	{
		return 0;
	}
	else
	{
		l = BinTreeDepth(root->lch);
		r = BinTreeDepth(root->rch);
		return l > r ? l + 1 : r + 1;
	}		
}

测试程序

int main(void)
{
    int loop = 1, num;
    char ch;
    TNODE *root;
    BinTreeCreate(&root);
    while (loop)
    {
        printf("I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > ");
        scanf(" %ch", &ch);
        ch = toupper(ch);
        switch (ch)
        {
            case 'I':
                printf("输入: ");
                BinTreeInput(&root);
                break;
            case 'O':
                printf("输出:\n");
                BinTreeOutput(root);
                break;
            case 'C':
                BinTreeClear(&root);
                printf("清空\n");
                break;
            case 'T':
                printf("遍历\n1-先序 2-中序 3-后序 0-返回 > ");
                scanf("%d", &num);
                if (num == 1)
                {
                    printf("先序遍历: ");
                    BinTreePreorder(root);
                    putchar('\n');
                }
                else if (num == 2)
                {
                    printf("中序遍历: ");
                    BinTreeInorder(root);
                    putchar('\n');
                }
                else if (num == 3)
                {
                    printf("后序遍历: ");
                    BinTreePostorder(root);
                    putchar('\n');
                }
                else if (num != 0)
                {
                    printf("不正确的遍历选项!\n");
                }
                break;
            case 'D':
                printf("数据\n1-结点数 2-叶子结点数 3-分枝结点数 4-深度 0-返回 > ");
                scanf("%d", &num);
                if (num == 1)
                {
                    printf("结点数: %d\n", BinTreeNumNode(root));
                }
                else if (num == 2)
                {
                    printf("叶子结点数: %d\n", BinTreeNumLeaf(root));
                }
                else if (num == 3)
                {
                    printf("分枝结点数: %d\n", BinTreeNumBranch(root));
                }
                else if (num == 4)
                {
                    printf("深度: %d\n", BinTreeDepth(root));
                }
                else if (num != 0)
                {
                    printf("不正确的数据选项!\n");
                }
                break;
            case 'Q':
                loop = 0;
                break;
            default:
                printf("不正确的操作选项!\n");
                break;
        }
    }
    BinTreeDestroy(&root);
    return 0;
}

运行效果

I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > x
不正确的操作选项!
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > I
输入: EIBJ##H###DF#A##G#C##
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > o
输出:
      C
    G
  D
      A
    F
E
  I
      H
    B
      J
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > t
遍历
1-先序 2-中序 3-后序 0-返回 > 9
不正确的遍历选项!
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > T
遍历
1-先序 2-中序 3-后序 0-返回 > 0
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > t
遍历
1-先序 2-中序 3-后序 0-返回 > 1
先序遍历: EIBJHDFAGC
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > T
遍历
1-先序 2-中序 3-后序 0-返回 > 2
中序遍历: JBHIEFADGC
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > t
遍历
1-先序 2-中序 3-后序 0-返回 > 3
后序遍历: JHBIAFCGDE
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > d
数据
1-结点数 2-叶子结点数 3-分枝结点数 4-深度 0-返回 > 9
不正确的数据选项!
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > D
数据
1-结点数 2-叶子结点数 3-分枝结点数 4-深度 0-返回 > 0
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > d
数据
1-结点数 2-叶子结点数 3-分枝结点数 4-深度 0-返回 > 1
结点数: 10
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > D
数据
1-结点数 2-叶子结点数 3-分枝结点数 4-深度 0-返回 > 2
叶子结点数: 4
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > d
数据
1-结点数 2-叶子结点数 3-分枝结点数 4-深度 0-返回 > 3
分枝结点数: 6
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > d
数据
1-结点数 2-叶子结点数 3-分枝结点数 4-深度 0-返回 > 4
深度: 4
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > c
清空
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > O
输出:
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > d
数据
1-结点数 2-叶子结点数 3-分枝结点数 4-深度 0-返回 > 1
结点数: 0
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > i
输入: ABD##E##CF##G##
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > o
输出:
    G
  C
    F
A
    E
  B
    D
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > d
数据
1-结点数 2-叶子结点数 3-分枝结点数 4-深度 0-返回 > 1
结点数: 7
I-输入 O-输出 C-清空 T-遍历 D-数据 Q-退出 > Q
极客李华
关注
  • 3
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
二叉树的创建（数据结构） C语言版
m0_67400973的博客
06-21 2万+
目录一.二叉树的存储结构二.二叉树的创建三.二叉树的遍历1.先序遍历2.中序遍历3.后序遍历4.层序遍历二叉树的基本存储结构如下所示leftchild:存储左孩子节点的地址rightchild:存储右孩子节点的地址data：当前节点存储的信息 二.二叉树的创建 创建一棵二叉树的关键在于如何将一个一个的节点按照树的脉络连接起来，在这里我们选择用一棵最小的满二叉树来说明我们需要首先创建根节点，并且向里面保存数据，然后接着在向左孩子里面输入数据，最后是右孩子，其实这种从根节点开始，依次访问左节点，右节点的方式叫做
二叉树创建C语言实现
02-24
通过链式存储结构实现二叉树的创建，包含如下操作： 1. 创建树； 2. 销毁树； 3. 清空树； 4. 插入结点； 5. 删除结点； 6. 获取结点； 7. 获取根结点； 8. 获取树的结点数； 9. 获取树的高度； 10. 获取树的度； 11. 显示二叉树。
二叉树的实现（C语言数据结构）
芊樱烛渊的博客
05-23 9636
一、以下是我们需要实现的功能 #pragma once #include <stdio.h> #include <stdlib.h> #include <assert.h> #include <stdbool.h> typedef char BTDataType; typedef struct BinaryTreeNode { BTDataType _data; struct BinaryTreeNode* _left; stru
【数据结构】C语言实现二叉树
蒙奇D索大的博客
07-02 1414
【数据结构】第五章——树与二叉树 详细介绍如何通过C语言实现一棵二叉树……
数据结构之二叉树（C语言附详细代码）
m0_68210771的博客
07-23 1万+
关于树的简要概念和二叉树的重点内容，以及二叉树的操作代码，前中后序遍历代码以及层次遍历代码
C语言学习之二叉树的实现详解
分享型博主
03-27 2012
include # include // 节点结构体 struct node {int data;// 节点数据 struct node * left;// 左子树指针 struct node * right;// 右子树指针 };// 新建节点 struct node * new_node(int data) {// 为新节点分配内存空间 node -> data = data;// 设置新节点数据 node -> left = NULL;
二叉树基本代码实现
m0_61548909的博客
03-30 4436
目录 1.二叉树的链式结构 2.二叉树的遍历 2.1先序遍历 2.2中序遍历 2.3后序遍历 3.二叉树的基本操作 3.1求二叉树结点个数 3.1.1全局遍历 3.1.2递归的思想分治 3.1.3局部变量 3.2求二叉树叶子结点个数 3.3求二叉树第K层结点个数 3.4求二叉树的深度/高度 3.5查找二叉树中值为x的结点 3.6二叉树的销毁 3.7运用队列实现广度优先的层序遍历 1.二叉树的链式结构 typedef int BTDataType; typ
二叉树的建立与查找（C语言）
qq_73884528的博客
05-16 3014
我们建立的二叉树只能向下查找，不能返回上层，所以要达到层次遍历效果可以多次遍历二叉树，每次遍历取其中一层来实现。我们先通过getHeightTree()获取二叉树的总高度，然后在遍历二叉树时分别对每层元素进行了查找。此外，先序遍历，中序遍历，后序遍历也可以采用非递归思路编写，以后补充，再见！所建二叉树较小数插入左侧，较大数插入右侧。建立二叉树过程与之前一样，多了队列建立和相关操作的代码，运行效果如下。通过这段代码可以建立一个二叉树,如图所示。第二种层次遍历可以通过递归方式实现。2.二叉树层次遍历方法。
C语言翻转二叉树.zip
10-27
在C语言中，处理二叉树通常涉及创建节点、插入节点、遍历以及各种操作，如翻转二叉树。这个名为"C语言翻转二叉树.zip"的压缩包可能包含了一个实现二叉树翻转的项目，该项目可能用于教学或实践目的。 二叉树的翻转，...
C语言编写二叉树的代码
最新发布
07-05
该二叉树代码不使用链表进行遍历，而是使用结构体里面包含变量已经多个该结构体本身的结构体指针进行遍历。定义一个结构体，包括数据变量，和两个自身的结构体指针(二叉树的左边遍历指针和右边遍历指针两个)。函数...
C语言平衡二叉树.zip
10-27
本文将深入探讨C语言实现平衡二叉树的相关知识点。 首先，我们要理解什么是二叉树。二叉树是每个节点最多有两个子节点的树形数据结构，通常分为左子节点和右子节点。二叉树的典型应用包括查找、排序等。对于二叉...
C语言二叉树详解
Sxy_wspsby的博客
12-03 8731
文章目录 概念 一、二叉树的性质 二、实现二叉树 总结 概念 一棵二叉树是结点的一个有限集合，该集合: 1. 或者为空 2. 由一个根节点加上两棵别称为左子树和右子树的二叉树组成 注意： 1. 二叉树不存在度大于2的结点 2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树 任意的二叉树都由下面几种情况组合而成： 二叉树中有两个非常特别的存在： 1.满二叉树： 一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就
C语言算法基础——二叉树的实现
weixin_52109967的博客
07-26 3758
菜鸟日常学习算法的总结！
c++二叉树详解（附基本操作代码版）
Yoyo的博客
07-10 5503
二叉树可以说是树形数据结构中最基础的，且在多种领域都有应用（比如语法树，二值决策树），熟悉其各种操作是必须的。char data;}BT;// 根据输入二点中序表达式和前序表达式创建一颗二叉树// 展示一颗二叉树，以A(B, C(D, E))这样加了括号的前序遍历来实现// 销毁二叉树// 判断这颗树是不是完全二叉树// 计算树的高度// 计算叶子的数量// 计算树的宽度// 层次遍历// 前序遍历// 中序遍历// 后序遍历。
c语言二叉树代码实现
小洁洁
01-12 1191
先简单介绍一下二叉树，这个词熟悉又陌生，通过字面了解就是每一个结点如果有叉，那最多只能有2个分支，这两个分支就叫做左子树和右子树。左子树和右子树是有顺序的，即使只有一棵子树也要区分是左子树还是右子树。
《数据结构C语言版》——二叉树详解(图文并茂)
青春无问西东 岁月自成芳华
05-20 1万+
C语言版本的数据结构详解，讲解树、二叉树及其对应的定义、建立、性质
C语言创建二叉树的方法（全）
热门推荐
qq_39838607的博客
07-08 2万+
创建二叉树 前言 一、二叉树的链式储存 二、前序，中序，后序 中序和先序建立二叉树 #号法创建二叉树
最简单的二叉树的创建，c语言完整代码展示
H17260003837的博客
08-20 2987
二叉树的创建
二叉树详解（C语言版）
qq_44075108的博客
04-09 9709
二叉树详解
用C语言写二叉树
05-24
下面是一个基本的二叉树的C语言实现： ```c #include <stdio.h> #include <stdlib.h> // 定义二叉树结构体 typedef struct TreeNode { int data; struct TreeNode* left; struct TreeNode* right; } TreeNode; // 创建一个新节点 TreeNode* create_node(int data) { TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode)); node->data = data; node->left = NULL; node->right = NULL; return node; } // 插入节点 void insert_node(TreeNode** root, int data) { if (*root == NULL) { *root = create_node(data); return; } if (data < (*root)->data) { insert_node(&((*root)->left), data); } else { insert_node(&((*root)->right), data); } } // 中序遍历 void inorder_traversal(TreeNode* root) { if (root != NULL) { inorder_traversal(root->left); printf("%d ", root->data); inorder_traversal(root->right); } } int main() { TreeNode* root = NULL; insert_node(&root, 6); insert_node(&root, 4); insert_node(&root, 8); insert_node(&root, 2); insert_node(&root, 5); insert_node(&root, 7); insert_node(&root, 9); inorder_traversal(root); printf("\n"); return 0; } ``` 这段代码创建了一个二叉树，并对其进行了中序遍历输出。在这个例子中，二叉树的每个节点都只包含一个整数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

极客李华

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值