简单二叉树的功能实现

已于 2022-10-23 21:33:51 修改
阅读量309 收藏
点赞数
分类专栏： 数据结构
于 2022-06-28 22:12:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54183294/article/details/125510850
版权

算法 数据结构

目录

简单二叉树功能的实现

下面的有两个功能一是程序遍历，二是判断是否为完全二叉树，里面有用到队列来实现
但是当我们没有学习c++时，要自己实现队列。

BinaryTree.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Queue.h"

typedef char BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;

BTNode* BuyBTNode(BTDataType data)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	if (node == NULL)
		return NULL;
	node->data = data;
	node->left = NULL;
	node->right = NULL;
	return node;
}
// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi)
 {
	if (a[*pi] == '#')
	{
		(*pi)++;
		return NULL;
	}

	BTNode* node = BuyBTNode(a[*pi]);
	(* pi)++;
	node->left = BinaryTreeCreate(a, n, pi);
	node->right = BinaryTreeCreate(a, n, pi);

	return node;
}

// 二叉树销毁
void BinaryTreeDestory(BTNode** root)
{
	if ((*root) == NULL)
	{
		return;
	}
	BinaryTreeDestory(&(*root)->left);
	BinaryTreeDestory(&(*root)->right);
	free(*root);
	*root = NULL;
}

// 二叉树节点个数（一）
int BinaryTreeSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}

	return BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;
}
// 二叉树节点个数（二）
int TreeSize2(BTNode* root)
{
	return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
}

// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	if (root->left == NULL && root->right == NULL)
	{
		return 1;
	}

	return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);
}

// 二叉树第k层节点个数（一）
int BinaryTreeLevelKSize(BTNode* root, int k)
{
	if (root == NULL)
	{
		return 0;
	}
	if (--k == 0)
	{
		return 1;
	}

	return BinaryTreeLevelKSize(root->left,k) + BinaryTreeLevelKSize(root->right,k);

}
// 二叉树第k层节点个数（二）
int TreeKLevel(BTNode* root, int k)
{
	assert(k >= 1);
	if (root == NULL)
		return 0;
	if (k == 1)
		return 1;

	return TreeKLevel(root->left, k - 1) + TreeKLevel(root->right, k - 1);

}

// 二叉树的深度
int TreeDepth(BTNode* root)
{
	if (root == NULL)
		return 0;
	int left = TreeDepth(root->left);
	int right = TreeDepth(root->right);

	return left > right ? left + 1 : right + 1;
}

// 二叉树查找值为x的节点（一）
// 一里面用了三目操作符，最好不要用，用方式二
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
	{
		return NULL;
	}
	if (root->data == x)
	{
		return root;
	}
	BTNode* tmp1 = BinaryTreeFind(root->left, x);
	BTNode* tmp2 = BinaryTreeFind(root->right, x);
	
	return tmp1 == NULL ? tmp2 : tmp1;
}
// 二叉树查找值为x的节点（二）
BTNode* TreeFind2(BTNode* root, BTDataType x)
{
	if (root == NULL)
		return NULL;

	if (root->data == x)
		return root;

	BTNode* ret1 = TreeFind2(root->left, x);
	if (ret1)
		return ret1;

	BTNode* ret2 = TreeFind2(root->right, x);
	if (ret2)
		return ret2;

	return NULL;
}
// 二叉树前序遍历 
void BinaryTreePrevOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("#->");
		return;
	}
	printf("%c->", root->data);
	BinaryTreePrevOrder(root->left);
	BinaryTreePrevOrder(root->right);
}

// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}
	BinaryTreeInOrder(root->left);
	printf("%c->", root->data);
	BinaryTreeInOrder(root->right);
}

// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}
	BinaryTreePostOrder(root->left);
	BinaryTreePostOrder(root->right);
	printf("%c->", root->data);
}

// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
	// 队列
	Queue q;
	QueueInit(&q);
	if (root)
	{
		QueuePush(&q, root);
	}

	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		printf("%c ", front->data);
		QueuePop(&q);

		if (front->left)
		{
			QueuePush(&q, front->left);
		}

		if (front->right)
		{
			QueuePush(&q, front->right);
		}
	}
	printf("\n");
	QueueDestroy(&q);

}

// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root)
{
	//队列(也入空)
	Queue q;
	QueueInit(&q);
	if (root)
	{
		QueuePush(&q, root);
	}

	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);

		if (front)
		{
			QueuePush(&q, front->left);
			QueuePush(&q, front->right);
		}
		else
		{
			// 遇到空以后，则跳出层序遍历
			break;
		}
	}
	//1. 如果后面全是空，则是完全二叉树
	//2. 如果空后面还有非空，则不是完全二叉树

	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);

		if (front)
		{
			//这里不要忘记销毁
			QueueDestroy(&q);
			return false;
		}
	}
	QueueDestroy(&q);
	return true;
}

//当需要自己创建二叉树时,可以根据二叉树的形状进行创建
BTNode* CreatBinaryTree()
{
	BTNode* n1 = BuyBTNode(1);
	BTNode* n2 = BuyBTNode(2);
	BTNode* n3 = BuyBTNode(3);
	BTNode* n4 = BuyBTNode(4);
	BTNode* n5 = BuyBTNode(5);
	BTNode* n6 = BuyBTNode(6);
	//BTNode* n7 = BuyBTNode(7);
	n1->left = n2;
	n1->right = n4;
	n2->left = n3;
	n4->left = n5;
	n4->right = n6;
	//n3->right = n7;

	return n1;
}
int main()
{
	
	BTNode* CreatBinaryTree();

	BTDataType a[] = "ABD##E#H##CF##G##";       
	int i = 0;
	BTNode* BT = BinaryTreeCreate(a, sizeof(a) / sizeof(a[0]), &i);
	BinaryTreePrevOrder(BT);
	printf("\n");

	int size = BinaryTreeSize(BT);
	printf("二叉树节点的个数: %d\n", size);

	int leafsize = BinaryTreeLeafSize(BT);
	printf("叶子节点的个数: %d\n", leafsize);

	int k = 5;
	int LevelKSize = BinaryTreeLevelKSize(BT, k);
	printf("第%d层节点的个数为: %d\n", k, LevelKSize);

	BTNode* FindNode = BinaryTreeFind(n1, 3);
	printf("找到的节点值:%d \n", FindNode->data);

	BinaryTreeLevelOrder(BT);

	int TreeC = BinaryTreeComplete(BT);
	printf("是不是完全二叉树:%d\n", TreeC);

	BinaryTreeDestory(&BT);
	BinaryTreeDestory(&n1);
	return 0;
}

Queue.h

**里面注意前面的相互引用**

#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

/*
涉及到相互引用，Queue.c要用到BTNode,但是BTNode的结构体放在BinaryTree.c中
BinaryTree.c又要用到队列，用前置声明告诉编译器，BTNode在其它文件中定义，到其它文件中去找
*/

//前置声明
struct BinaryTreeNode;


typedef struct BinaryTreeNode* QDataType;
typedef struct QListNode
{
	struct QListNode* next;
	QDataType data;
}QNode;

typedef struct Queue
{
	QNode* head;
	QNode* tail;
}Queue;

void QueueInit(Queue* pq);

void QueueDestroy(Queue* pq);

void QueuePush(Queue* pq, QDataType data);

void QueuePop(Queue* pq);

QDataType QueueFront(Queue* pq);

QDataType QueueBack(Queue* pq);

int QueueSize(Queue* pq);

bool QueueEmpty(Queue* pq);

Queue.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Queue.h"

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = NULL;
	pq->tail = NULL;
}
QNode* BuyQueueNode(QDataType data)
{
	QNode* temp = (QNode*)malloc(sizeof(QNode));
	assert(temp);
	temp->next = NULL;
	temp->data = data;
	return temp;
}
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = NULL;
	pq->tail = NULL;
}

void QueuePush(Queue* pq, QDataType data)
{
	assert(pq);
	if (pq->head == NULL)
	{
		pq->head = pq->tail = BuyQueueNode(data);
	}
	else
	{
		// 尾插
		pq->tail->next = BuyQueueNode(data);
		pq->tail = pq->tail->next;
	}
}

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	// 1.一个节点
	// 2.一个以上节点
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}

}

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->head->data;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));

	return pq->tail->data;
}

int QueueSize(Queue* pq)
{
	assert(pq);
	int size = 0;
	QNode* cur = pq->head;
	while (cur)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL;
}

二叉树的一些题目

单值二叉树 链接

如果二叉树每个节点都具有相同的值，那么该二叉树就是单值二叉树。

只有给定的树是单值二叉树时，才返回 true；否则返回 false。

void PreOrderCompare(struct TreeNode* root, int val)
{
    if(root == NULL || flag == false)
    {
        return;
    }

    if(root->val != val)
    {
        flag = false;
        return;
    }
    PreOrderCompare(root->left, val);
    PreOrderCompare(root->right, val);
}
bool isUnivalTree(struct TreeNode* root){
    if(root == NULL)
    {
        return true;
    }

    // 这里一定不要忘记flag = true,因为函数会调用多次
    flag = true;
    PreOrderCompare(root,root->val);
    return flag;
}

//
    bool isUnivalTree(TreeNode* root) {
        if(root == NULL)
            return true;
        if((root->left && root->left->val != root->val) || (root->right && root->right->val != root->val))
            return false;

        return isUnivalTree(root->left) && isUnivalTree(root->right);
    }

相同的树 链接

给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

相同的树：比较两棵树是否相同
特殊判断：如果两棵树都是空树那么必然相同；如果两棵树其中只有一棵树为空树那么必不相同
返回值：两棵树都非空+根节点值相同+左子树相同+右子树相同

bool isSameTree(struct TreeNode* p, struct TreeNode* q){
    if(p == NULL && q == NULL)
    {
        return true;
    }

    // 结构
    // if((p == NULL && q != NULL) || (p != NULL && q == NULL))
    // {
    //     return false;
    // }

    if(p == NULL || q == NULL)
    {
        return false;
    }
    if(p->val != q->val)
    {
        return false;
    }

    return isSameTree(p->left,q->left) && isSameTree(p->right,q->right);
}

翻转二叉树链接

将一棵二叉树镜像翻转
特殊判断：空树的镜像翻转树仍然是本身
思路：翻转左子树后替换右子树，翻转右子树后替换左子树
TreeNode*invertTree(TreeNode*root)
{
    if (!root)
        return nullptr;
    TreeNode*left = invertTree(root->left);
    TreeNode*right = invertTree(root->right);
    root->left = right;
    root->right = left;
    return root;
}


    int height(TreeNode*root)
    {
        if (root == NULL)
            return 0;
        else
            return max(height(root->left), height(root->right)) + 1;
    }
    bool isBalanced(TreeNode* root) {
        if(root == NULL)
            return true;
        // 注意如果像把判断分开写在return外面，要返回为假的情况，这样当为真时会向下继续
        if(abs(height(root->left) - height(root->right)) > 1)
            return false;

        return isBalanced(root->left) && isBalanced(root->right);
    }
    //
	bool isSameTree(TreeNode*p, TreeNode*q)
	{
	    if (!p && !q)
	        return true;
	    return p && q && p->val == q->val && (isSameTree(p->left, q->left)) && (isSameTree(p->right, q->right));
	}

对称的树 链接

给你一个二叉树的根节点 root ， 检查它是否轴对称。

在这里插入图片描述

bool isSameTree(struct TreeNode* p, struct TreeNode* q){
    if(p == NULL && q == NULL)
    {
        return true;
    }

    if(p == NULL || q == NULL)
    {
        return false;
    }
    if(p->val != q->val)
    {
        return false;
    }

    // 这里要注意，对称是左和右比较，右和左比较
    return isSameTree(p->left,q->right) && isSameTree(p->right,q->left);
}

bool isSymmetric(struct TreeNode* root){
    if(root == NULL)
    {
        return true;
    }

    return isSameTree(root->left, root->right);
}

合并二叉树链接

    // 创建新的节点
    // TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
    //     if(root1 == NULL)
    //         return root2;
    //     if(root2 == NULL)
    //         return root1;

    //      TreeNode* root =  new TreeNode(root1->val + root2->val);
    //      root->left = mergeTrees(root1->left, root2->left);
    //      root->right = mergeTrees(root1->right, root2->right);

    //      return root;
    // }

    // 用已有的节点 root1;
        TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(root1 == NULL)
            return root2;
        if(root2 == NULL)
            return root1;

        root1->val = root1->val + root2->val;
        root1->left = mergeTrees(root1->left, root2->left);
        root1->right = mergeTrees(root1->right, root2->right);
        

         return root1;
    }

另一棵树的子树 链接

给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。

二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

方式一（推荐方式二）
// bool flag = true;
// bool IsSameTree(struct TreeNode* root, struct TreeNode* subRoot)
// {
//     if(root == NULL && subRoot == NULL)
//     {
//         return true;
//     }

//     if(root == NULL || subRoot == NULL)
//     {
//         return false;
//     }

//     if(root->val != subRoot->val)
//     {
//         return false;
//     }
    
//     return IsSameTree(root->left, subRoot->left) && IsSameTree(root->right, subRoot->right);
// }
// void TreeFind(struct TreeNode* root,struct TreeNode* subRoot)
// {
//     if(root == NULL || flag == true)
//     {
//         return;
//     }

//     if(root->val == subRoot->val)
//     {
//         flag = IsSameTree(root, subRoot);
//         if(flag ==true)
//             return;
//     }
//     TreeFind(root->left, subRoot);
//     TreeFind(root->right, subRoot);

//     return;
// }
// bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot){
//     if(root == NULL && subRoot == NULL)
//     {
//         return true;
//     }

//     flag = false;
//     TreeFind(root, subRoot);
//     return flag;
// }

（方式二）
bool IsSameTree(struct TreeNode* root, struct TreeNode* subRoot)
{
    if(root == NULL && subRoot == NULL)
    {
        return true;
    }

    if(root == NULL || subRoot == NULL)
    {
        return false;
    }

    if(root->val != subRoot->val)
    {
        return false;
    }
    return IsSameTree(root->left, subRoot->left) && IsSameTree(root->right, subRoot->right);
}
bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot){
    if(root == NULL)
    {
        return false;
    }

    // 遍历：和root所有子树都比较一边
    if(IsSameTree(root,subRoot))
    {
        return true;
    }

    // 只要有一个子树和subRoot相同就可以了

    return isSubtree(root->left, subRoot) || isSubtree(root->right, subRoot);
}

I/O型的创建二叉树 链接

编一个程序，读入用户输入的一串先序遍历字符串，根据此字符串建立一个二叉树（以指针方式存储）。 例如如下的先序遍历字符串： ABC##DE#G##F### 其

中“#”表示的是空格，空格字符代表空树。建立起此二叉树以后，再对二叉树进行中序遍历，输出遍历结果。

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef char BTDataType;

typedef struct BinaryTreeNode
{
    BTDataType data;
    struct BinaryTreeNode* left;
    struct BinaryTreeNode* right;
}BTNode;

BTNode* BuyNode(BTDataType data)
{
    BTNode* node = (BTNode*)malloc(sizeof(BTNode));
    assert(node);
    node->data = data;
    node->left = NULL;
    node->right = NULL;
    return node;
}
BTNode* BinaryTreeCreat(BTDataType* a, int* pi)
{
    if(a[*pi] == '#')
    {
        (*pi)++;
        return NULL;
    }
    BTNode* node = BuyNode(a[(*pi)++]);
    node->left = BinaryTreeCreat(a, pi);
    node->right = BinaryTreeCreat(a, pi);

    return node;
}

void PostOrder(BTNode* root)
{
    if(root == NULL)
    {
        return;
    }
    PostOrder(root->left);
    printf("%c ",root->data);
    PostOrder(root->right);
}

void DistroyNode(BTNode* root)
{
    if(root == NULL)
    {
        return;
    }
    DistroyNode(root->left);
    DistroyNode(root->right);
    free(root);
}
int main()
{
    BTDataType a[100];
    scanf("%s",a);
    int pi = 0;
    BTNode* node = BinaryTreeCreat(a,&pi);
    PostOrder(node);
    DistroyNode(node);
    
    return 0;
}
~小火苗
关注
专栏目录
二叉树的三种遍历非递归实现
ryjflyshy的博客
10-16 4万+
二叉树的遍历实现
二叉树的基本功能实现方法（C++）
Clair1024的博客
08-31 315
假设：有一个n个元素的完全二叉树，为了使其成为满二叉树，补全没有孩子的节点是的除了叶节点所有节点都有两个孩子，即最低层皆为-1. 例1： 　　　　　　　　　　　　　　1 　　　　　　　　　2 　　　　　　　　3 　　　　　　4　　　　 5 　　　　-1 　　　6 　　　　　-1 -1 　-1 -1 　-1 -1 ...
二叉树基础功能代码实现（Java语言带注释）
qq_46116963的博客
03-12 1159
用java语言实现基础二叉树，并进行测试。 实现功能：二叉树的前中后序遍历，层序遍历，统计节点个数，统计叶子结点个数，查找元素是否在二叉树中，获取二叉树高度，求出树中第k层的节点个数。（包含递归方法与非递归方法） 代码实现（Java语言） package bin_tree; import java.util.ArrayDeque; import java.util.Deque; import java.util.LinkedList; import java.util.Queue;...
c++二叉树树的基本功能实现
m0_56719462的博客
10-22 227
通过在类中创建公有函数及私有函数,让公有函数调用私有函数(公有函数的用处在于给私有函数传参,调用私有函数,而公有函数调用无惨),以实现用户调用不需要参数的方便. 代码如下 #include <iostream> #include <fstream> using namespace std; template <class T> struct BinTreeNode { // 二叉树结点类定义 T data; // 数据域 BinTreeNo
二叉树的常用功能实现(java)
qq_22993855的博客
08-27 264
二叉树的常用功能实现 二叉树的功能 1.二叉树前中后序遍历代码实现 2.二叉树前中后序查找指定节点代码实现 3.二叉树删除指定节点代码实现 package com.bingym.tree; public class BinaryTreeDemo { /* * 二叉树的前中后序遍历 * 分析:首先我们需要创建一个二叉树(即需要root节点即可) * 前序遍历: * 先输出当前节点(初始即为root节点) * 如果当前节点的左子节点不为空,则递归继续进行前序遍历
二叉树实现简易计算器
10-10
### 二叉树实现简易计算器 #### 概述 本文档介绍了一个利用二叉树来实现简易计算器的程序。此程序能够处理用户通过键盘输入的中缀表达式，并将其转换为二叉表达式树，进而通过后序遍历计算出表达式的值。此外，...
二叉树的简单实现
01-26
`binarytree.c` 文件很可能是实现二叉树功能的源代码。在这个程序中，我们可能会看到以下几个关键部分： 1. **二叉树节点定义**：通常会定义一个结构体，用于存储节点的数据以及指向左右子节点的指针。例如： ```c...
二叉树的实现
11-18
简单二叉树的功能实现//结构体以及全局变量声明区域 typedef int BoolStatus; typedef char TElemType; typedef struct BiTNode { TElemType data; struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; typedef ...
线索二叉树的实现.doc
最新发布
04-29
课题的核心在于如何在已有的二叉树基础上，通过一定的逻辑设计与详细设计步骤，实现线索化的功能。 #### 2. 设计要求 - **逻辑设计**：首先要明确抽象数据类型（ADT）的定义，确定二叉树节点的数据结构以及线索化...
数据结构二叉树，c语言简单实现
01-12
在C语言中实现二叉树，我们需要定义一个结构体来表示二叉树节点，一般包括两个指针域，分别存储左右子节点，以及一个数据域存储实际的数据。以下是一个基本的二叉树节点定义： ```c typedef struct TreeNode { int...
二叉树基本操作代码（C语言）
qq_62888595的博客
02-03 625
二叉树基本插座（c语言）最齐全的代码
数据结构篇——二叉树
handsomeRE的博客
07-18 1109
数据结构篇——二叉树
＜数据结构＞二叉树功能实现
weixin_46364330的博客
10-31 767
文章目录前言一、二叉树基本操作的实现二、使用步骤1.二叉树基本功能2.读入数据总结 前言 提示：本篇主要是本小白大学期间对数据结构实验的一些基本代码功能实现，希望对一同数据结构的伙伴有所帮助。 提示：以下是本篇文章正文内容，下面案例可供参考 一、二叉树基本操作的实现 二叉树的顺序存储结构 1.申请一块（足够大）的连续存储空间 2.若不是完全二叉树则转化为完全二叉树 3.按上到下，从左到右的顺序编号 4.按编号依次存储在连续空间中，若节点为空，则用特殊符号表示 缺点：对非完全二叉树浪费空间 二叉树的遍
二叉树基本代码实现
m0_61548909的博客
03-30 4468
目录 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
下列代码的功能是将二叉树T中的结点按照层序遍历的顺序输出
国家一级致癌物
12-12 3142
填空题 下列代码的功能是将二叉树T中的结点按照层序遍历的顺序输出。 typedef struct TreeNode* Tree; struct TreeNode { int Key; Tree Left; Tree Right; }; void Level_order(Tree T) { Queue Q; if (!T) return; Q = CreateQueue(MaxElements); Enqueue(T, Q); while
算法-二叉树：二叉树的最小深度
weixin_60952096的博客
02-07 1511
算法-二叉树：二叉树的最小深度 求一颗二叉树的最小深度，根节点的深度为1。最小深度：从根节点到最近叶子节点的最短路径上的节点数量。 //方法一：递归 int height(TreeNode* root){ if(root == NULL) return 0; //如果左子树为空，那么最小深度按照右子树计算 if(!root->left && root->right){ return 1+height(root->right)
二叉树的实现（C语言数据结构）
芊樱烛渊的博客
05-23 9680
一、以下是我们需要实现的功能 #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++二叉树基础 12.30
sdwsyns的博客
05-26 330
二叉树结构： struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; 二叉树的遍历方式: 前序序列：根左右 (递归中常用到) 中序序列：左根右 后序序列：左右根 算法相关： （ps:原设定，一棵树只有一个节点或没有节点，它的深度都为0，而这里对于空节点的深度设定为-1，只有一个节点深度设为0） 1.计算二叉树深度 int height
【数据结构】二叉树的实现&递归遍历（完整代码）
热门推荐
ly_6699的博客
02-23 1万+
二叉树实现的功能包含以下内容： 1.按要求创建一棵树 2.计算树节点，树叶子节点的个数 3.输出树中第n层的节点个数 4.关于树前序，中序，后序的递归遍历 5.树的层序遍历 6.判断树是否为完全二叉树 7.树的前序，中序，后序的非递归遍历 >二叉树的递归遍历:直接按遍历顺序递归调用 >二叉树的层序遍历可以借用队列结构来实现 >二叉树的非递归遍历可以借用栈结构来实现 > **前序遍历: 根 -- 左 -- 右 > 中序遍历: 左 -- 根 -- 右 > 后序遍历: 左 -- 右 -- 根**
C语言实现简单二叉树的创建与遍历
"本资源是一份关于C语言实现简单二叉树的程序代码，包括创建二叉树、前序遍历、中序遍历和后序遍历以及计算二叉树深度的功能。通过这些函数，我们可以学习和理解二叉树的基本概念和操作在编程中的应用。 1. **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值