C++二叉树的一些基础

原创 已于 2024-06-22 12:54:27 修改 · 797 阅读 · 21 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
于 2024-06-11 13:25:01 首次发布

目录

C++二叉树的一些基础

参考

树节点的结构体

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode() : val(0), left(nullptr), right(nullptr) {}//无参构造
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}// 一个带有一个参数 x 的构造函数。它将 val 初始化为提供的值 x，并将 left 和 right 指针都设置为 nullptr
    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
};

单独创建树节

#include <iostream>

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

int main() {
	
    TreeNode* root = new TreeNode(1);
    root->left = new TreeNode(2);
    root->right = new TreeNode(3);
    root->right->left = new TreeNode(4);
    root->right->right = new TreeNode(5);

    return 0;
}

使用数组层次遍历建立二叉树

对于树的空节点，数组应该设置为NULL

vector<int>v = { 3,9,20,NULL,NULL,15,7 };// 在 C++中，NULL 被定义为整形常量 0

TreeNode* buildTree(vector<int>& nums)//层次遍历建立二叉树
{
 if (nums.empty()) return nullptr;
 TreeNode* root = new TreeNode(nums.front());
 vector<TreeNode*> q = { root };
 int i = 1;
 while (!q.empty() && i < nums.size())
 {
	 TreeNode* cur = q.front();
	 //q.assign(q.begin() + 1, q.end());
	 q.erase(q.begin());
	 if (i < nums.size())
	 {
		 cur->left = new TreeNode(nums[i++]);//层次遍历下，一个根节点的子节点按数组读取的顺序，左在前，右在后
		 q.push_back(cur->left);//将cur->left作为根节点添加到q中下次使用
	 }
	 if (i < nums.size())
	 {
		 cur->right = new TreeNode(nums[i++]);
		 q.push_back(cur->right);
	 }
 }
 return root;
}

层次遍历打印输出二叉树

广度优先

void levelOrderPrint(TreeNode* root)//层次遍历打印输出树，广度优先搜索
{
 if (!root) return;//空树
 vector<TreeNode*> q = { root };
 while (!q.empty())
 {
	 int size = q.size();
	 for (int i = 0; i < size; i++)
	 {
		 TreeNode* cur = q.front();
		 //q.assign(q.begin() + 1, q.end());
		 //q.front()与q.begin()的区别，q.front()返回头部的元素，q.begin()返回迭代器
		 q.erase(q.begin());
		 cout << cur->val << " ";
		 if (cur->left)
			 q.push_back(cur->left);
		 if (cur->right)
			 q.push_back(cur->right);
	 }
	 cout << endl;
 }
}

二叉树的深度优先遍历（Depth-First Search, DFS）包括三种基本的方式：先序遍历（Pre-order Traversal）、中序遍历（In-order Traversal）和后序遍历（Post-order Traversal）。

先序，中序，后序遍历输出二叉树

void preOrderTraversal(TreeNode* root) {
    if (root == nullptr) {
	        return;
    }
    cout << root->val << " ";
    preOrderTraversal(root->left);
    preOrderTraversal(root->right);
}

void inOrderTraversal(TreeNode* root) {
    if (root == nullptr) {
	        return;
    }
    inOrderTraversal(root->left);
    cout << root->val << " ";
    inOrderTraversal(root->right);
}

void postOrderTraversal(TreeNode* root) {
    if (root == nullptr) {
	        return;
    }
    postOrderTraversal(root->left);
    postOrderTraversal(root->right);
    cout << root->val << " ";
}

计算二叉树最大深度

递归，深度优先

int maxDepth(TreeNode* root) 
{
    if (root == nullptr) return 0;
	int leftDepth = maxDepth(root->left);
	int rightDepth = maxDepth(root->right);
	return max(leftDepth, rightDepth) + 1;
}

计算二叉树中指定层的节点数量

使用递归，深度优先

int countNodesAtLevel(TreeNode* root, int level)
{
    if(root == nullptr) return 0;
    if(level == 0) return 1;
    return countNodesAtLevel(root->left, level - 1) + countNodesAtLevel(root->right, level - 1);
}

判断两棵树 的叶子节点是否相似（值 和 顺序）

872.叶子相似的树
递归，深度优先

void dfs(vector<int> &v, TreeNode* root)
{
 if (root->left == nullptr && root->right == nullptr)
 {
	 v.push_back(root->val);
 }
 else
 {
	 if (root->left != nullptr)
	 {
		 dfs(v, root->left);
	 }
	 if (root->right != nullptr)
	 {
		 dfs(v, root->right);
	 }
 }
}
//什么时候递归结束呢，当节点左右指针都是空，即遇到叶子节点，递归结束
bool leafSimilar(TreeNode* root1, TreeNode* root2)//872.叶子相似的树
{
 vector<int> v1;
 dfs(v1, root1);
 vector<int> v2;
 dfs(v2, root2);
 return v1 == v2;//vector容器支持比较操作
}

改进

void dfs(vector<int> &v, TreeNode* root)
{
 if(root == nullptr) return;//如果返回类型是void，直接return;
 if (root->left == nullptr && root->right == nullptr)
 {
	 v.push_back(root->val);
 }
 dfs(v, root->left);
 dfs(v, root->right);
}

1448.统计二叉树中好节点的数目

给你一棵根为 root 的二叉树，请你返回二叉树中好节点的数目。
「好节点」X 定义为：从根到该节点 X 所经过的节点中，没有任何节点的值大于 X 的值。

示例 1：
输入：root = [3,1,4,3,null,1,5]
输出：4
解释：图中蓝色节点为好节点。
根节点 (3) 永远是个好节点。
节点 4 -> (3,4) 是路径中的最大值。
节点 5 -> (3,4,5) 是路径中的最大值。
节点 3 -> (3,1,3) 是路径中的最大值。

示例 2：
输入：root = [3,3,null,4,2]
输出：3
解释：节点 2 -> (3, 3, 2) 不是好节点，因为 “3” 比它大。

示例 3：
输入：root = [1]
输出：1
解释：根节点是好节点。

int dfs_1448(TreeNode* root, int path_max)
{
 if (root == nullptr) return 0;
 int res = 0;
 if (root->val >= path_max)
 {
	 res++;
	 path_max = root->val;
 }
 res += dfs_1448(root->left, path_max) + dfs_1448(root->right, path_max);
 return res;
}

int goodNodes(TreeNode* root)//1448.统计二叉树中好节点的数目
{
 return dfs_1448(root, INT_MIN);//INT_MIN是最小int
}

void test1448()
{
 vector<int>v1 = { 3,1,4,3,NULL,1,5 };
 TreeNode* tree1 = buildTree(v1);
 int num = goodNodes(tree1);
 cout << "num " << num << endl;
 cout << INT_MIN << endl;
}

错误版本

int dfs_1448(TreeNode* root, int path_max)
{
 if (root == nullptr) return 0;
 int res = 0;
 if (root->val >= path_max)
 {
	 res++;
	 path_max = root->val;
 }
 if(root->left != nullptr )
 {
 	int res1 = dfs_1448(root->left,max);
 }
 if(root->right != nullptr)
 {
 	int res2 = dfs_1448(root->right,max);
 }
 res = res + res1 + res2;
 return res;
}
//错误原因：res1 和 res2 在递归调用 dfs 之后才会返回，你不能在当前函数的这一层直接使用它们

所以以后先递归调用，然后判断比较好
那么改进上一道题872.叶子相似的树

437.路径总和III

给定一个二叉树的根节点 root ，和一个整数 targetSum ，求该二叉树里节点值之和等于 targetSum 的 路径 的数目。
可以从任意节点开始计数，只要向下就行

这题用两次循环
一次从任意结点开始
一次向下遍历求和

int dfs_437(TreeNode* root, int targetSum)
{
 if (root == nullptr) return 0;
 int num = 0;

 if (root->val == targetSum)
 {
	 num++;
	 //path = 0;
 }
 num += dfs_437(root->left, targetSum - root->val);
 num += dfs_437(root->right, targetSum - root->val);
 
 //递归内部的数不会被记录，所以每次递归都要想办法把变化的数传下去
 //这里需要传递的变量有两个，num,targetSum - root->val
 //如果计算节点值累加，累加的数无法传递，只能用目标值递减的办法targetSum - root->val
 
 return num;
}
int pathSum(TreeNode* root, int targetSum)//437.路径总和III
{
 if (root == nullptr) return 0;
 int num = dfs_437(root, targetSum);
 num += pathSum(root->left, targetSum);//相当于第一层循环
 num += pathSum(root->right, targetSum);
 return num;
}
void test437()
{
 vector<int>v1 = { 10,5,-3,3,2,NULL ,11,3,-2,NULL,1 };
 TreeNode* tree1 = buildTree(v1);
 int num = 8;
 int path_num = pathSum(tree1, num);
 cout << "path_num " << path_num << endl;
}

100.相同的树

判断两棵树是否相同

bool isSameTree(TreeNode* p, TreeNode* q)//100.相同的树
{
	
	if (p == nullptr && q == nullptr) return true;
	else if (p == nullptr || q == nullptr)
	{
		return false;
	}
	else if (p->val != q->val)
	{
		return false;
	}
	else 
	{
		return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
	}

}

226.翻转二叉树

TreeNode* invertTree(TreeNode* root) //226.翻转二叉树
{
	if (root == nullptr) return root;
	TreeNode* temp;
	temp = root->left;
	root->left = root->right;
	root->right = temp;
	invertTree(root->left);
	invertTree(root->right);
	return root;
}

101.对称二叉树

bool dfs_101(TreeNode* node1, TreeNode* node2)
{
	if (node1 == nullptr && node2 == nullptr) return true;
	else if (node1 == nullptr || node2 == nullptr) return false;
	else
	{
		return node1->val == node2->val&& dfs_101(node1->left, node2->right)&& dfs_101(node1->right, node2->left);
	}

}
bool isSymmetric(TreeNode* root)//101.对称二叉树
{
	
	TreeNode* left = root->left;
	TreeNode* right = root->right;
	return dfs_101(left, right);
}

112.路经总和

bool hasPathSum(TreeNode* root, int targetSum)//112.路经总和
{
	if (root == nullptr) return false;
	else if (root->left == nullptr && root->right == nullptr)//找到叶子节点
	{
		return root->val == targetSum;
	}
	else
	{
		return hasPathSum(root->left, targetSum - root->val) || hasPathSum(root->right, targetSum - root->val);
	}
}

129.求根节点到叶节点数字之和

给你一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字。
每条从根节点到叶节点的路径都代表一个数字：

例如，从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123 。
计算从根节点到叶节点生成的 所有数字之和 。
叶节点 是指没有子节点的节点。

示例 1：

输入：root = [1,2,3]
输出：25
解释：
从根到叶子节点路径 1->2 代表数字 12
从根到叶子节点路径 1->3 代表数字 13
因此，数字总和 = 12 + 13 = 25

int dfs_129(TreeNode* root,int prevSum)
{
	 
	if (root == nullptr) return 0;
	int sum = root->val + prevSum * 10;
	if (root->left == nullptr && root->right == nullptr)
	{
		return sum;
	}
	else
	{
		return dfs_129(root->left,sum) + dfs_129(root->right,sum);
	}
}
int sumNumbers(TreeNode* root) //129.求根节点到叶节点数字之和
{
	return dfs_129(root, 0);
}

有一个思考，在dfs中的return sum;之后是否就结束了整个递归
答案是没有，只是结束了这层递归，把结果返回给了上层递归，整个递归在遍历完整个树才结束

/////////////////////////////////////层次遍历///////////////////////////////////

199.二叉树的右视图

vector<int> rightSideView(TreeNode* root) //199.二叉树的右视图
{
	vector<int> v;
	if (root == nullptr) return {};	
	vector<TreeNode*> q = { root };
	while (!q.empty())
	{
		int size = q.size();
		for (int i = 0; i < size; i++)
		{
			TreeNode* cur = q.front();
			cout << cur->val << " ";
			q.erase(q.begin());

			if (i == size - 1)
				v.push_back(cur->val);//这一层末尾节点值就是需要的
			
			if (cur->left)
				q.push_back(cur->left);//将下一层的节点加入队列
				
			if (cur->right)
				q.push_back(cur->right);
		}
		cout << endl;
	}
	return v;
}

637.二叉树的层平均值

vector<double> averageOfLevels(TreeNode* root) //637.二叉树的层平均值
{
	vector<double> v;
	if (root == nullptr) return {};
	vector<TreeNode*> q = { root };
	while (!q.empty())
	{
		int size = q.size();
		double sum = 0;
		for (int i = 0; i < size; i++)
		{
			TreeNode* cur = q.front();
			cout << cur->val << " ";
			q.erase(q.begin());
			sum += cur->val;

			if (cur->left)
				q.push_back(cur->left);//将下一层的节点加入队列

			if (cur->right)
				q.push_back(cur->right);
		}
		cout << endl;
		v.push_back(sum / size);
	}
	return v;
}

102.二叉树的层次遍历

vector<vector<int>> levelOrder(TreeNode* root) //102.二叉树的层次遍历
{
	
	vector<vector<int>> v;
	if (root == nullptr) return {};
	vector<TreeNode*> q = { root };
	while (!q.empty())
	{	
		vector<int> temp;
		
		cout <<"size " << size << endl;
		cout <<"q.size() " << q.size() << endl;
		int size = q.size();
		for (int i = 0; i < size; i++)
		//for (int i = 0; i < q.size(); i++)
		{

			TreeNode* cur = q.front();
			cout << cur->val << " ";
			q.erase(q.begin());	
			temp.push_back(cur->val);

			if (cur->left)
				q.push_back(cur->left);

			if (cur->right)
				q.push_back(cur->right);
		}
		cout << endl;
		v.push_back(temp);
	}
	return v;
}

找了半天的一个BUG
int size = q.size();
for (int i = 0; i < size; i++) {}
和
for (int i = 0; i < q.size(); i++){}有什么区别
第二种是错误的，因为如果循环体内q改变，那么每次循环，条件都会变
第一种size不会改变

标签
#c++ #数据结构 #算法
c++ set遍历_C/C++数据结构——二叉树
weixin_39588223的博客
12-29 744
1.二叉树概念及基本术语二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。这种数据结构常用于查找，也运用于unix等常见操作系统的文件系统中。c++ STL(标准模板库)中的set和map也是使用二叉树中的红黑树实现。图 1- 11.1 二叉树基本术语(1). 树的结点：包含一个数据元素及若干指向子树的分支；例图...
C++二叉树的基本操作
wfanyue的博客
06-16 902
#include <iostream> using namespace std; class BinaryTree ; class BinTreeNode //结点类的定义 { friend BinaryTree; private: BinTreeNode *leftChild, *rightChil...
C++ 二叉树的基本操作
zhw864680355的博客
03-27 3586
对于一棵二叉树，有三种基本遍历方式： 1、前序遍历（DLR）：先访问根结点，然后遍历左子树，最后遍历右子树。 归结为：从根结点一直从左子树向下直到叶结点，然后返回到叶结点的父亲，再从其父结点的右子树向下。 2、中序遍历（LDR）：先中序遍历左子树，然后访问根结点，最后遍历右子树。 3、后序遍历（LRD）：先后序遍历左子树，然后遍历右子树，最后访问根结点。 对如上图，遍历结果如下： 前...
C++二叉树理论基础
qq_46780256的博客
01-23 1445
目录 二叉树性质 ​二叉树种类 满二叉树 完全二叉树 二叉搜索树 ​平衡二叉搜索树 二叉树存储方式 二叉树的遍历方式 二叉树的定义 二叉树性质 二叉树种类 满二叉树 如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。 完全二叉树 在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~2^h -1 个节点。...
【C++刷题】二叉树基础OJ题
tan_run的博客
04-11 801
记录C++刷题，二叉树基础题，包括：965. 单值二叉树 104. 二叉数的最大深度 144. 二叉树的前序遍历 100. 相同的树 101. 对称二叉树 572. 另一棵树的子树 牛客网KY11 二叉树遍历
【C++ 006】二叉树的基础理论
qq_44917064的博客
04-17 430
！请大家可以去b站进行关注和学习。
C++实现基础二叉树项目实践
weixin_35677363的博客
05-17 1137
在计算机科学中，二叉树是一种重要的数据结构，它是每个节点最多有两个子节点的树结构。通常子节点被称作“左子节点”和“右子节点”。二叉树在各种算法和数据处理领域中扮演着核心角色，比如用于搜索、排序、索引和数据存储等。二叉树的几个基本概念包括：根节点：没有父节点的顶级节点。叶子节点：没有子节点的节点。父节点：除根节点外，任意节点的直接上层节点。子树：任何一个节点及其所有子孙节点构成的二叉树。
二叉树及其应用：从基础到实践（C++ 版本）
B5201234的博客
12-06 1112
二叉树是一种树形数据结构，其中每个节点最多有两个子节点，分别称为左子节点和右子节点。根节点是树的起点；叶子节点没有子节点；高度是树中从根节点到叶子节点最长路径的边数。本文介绍了二叉树的基本概念、常见操作及其应用场景，通过 C++ 代码详细实现了二叉树的创建、遍历、二叉搜索树的插入与查找操作。二叉树是一种高效且灵活的数据结构，其应用广泛，学习和掌握它是编程进阶的重要一步。如果有疑问，欢迎留言讨论！
使用C++实现二叉树：从基础到完整实现
CWT19940910的博客
03-07 707
二叉树是一种重要的数据结构，广泛应用于搜索、排序、表达式求值等领域。本文将从二叉树的定义、核心操作（插入、遍历）以及内存管理等方面，详细讲解如何用C++实现一个功能完整的二叉树类。二叉树由若干。
1、C++算法之代码随想录（二叉树）——理论基础
qq_55527904的博客
04-28 292
C++自定义二叉树结构体int val;
【C++学习】深入理解二叉树：从基础概念到搜索二叉树和平衡二叉树的 C++ 实现
qq_42647082的博客
03-05 845
本文系统讲解二叉树的基本概念、度与层的关系、各类性质定理，再深入剖析二叉搜索树（BST）与平衡二叉树（AVL 树）的定义、特殊性质、优缺点、核心操作与 C++ 完整实现。适合从入门到面试全阶段阅读。
二叉树基础通关教程（C++ 版）
最新发布
Du_chong_huan的博客
03-30 170
LeetCode / 考试常用，数组按层序，逐个 new 节点，手动连接左右孩子。
c++二叉树_深入学习二叉树 (二叉树基础)
weixin_39986169的博客
11-23 105
前言树是数据结构中的重中之重，尤其以各类二叉树为学习的难点。一直以来，对于树的掌握都是模棱两可的状态，现在希望通过写一个关于二叉树的专题系列。在学习与总结的同时更加深入的了解掌握二叉树。本系列文章将着重介绍一般二叉树、完全二叉树、满二叉树、、、、平衡二叉树、红黑树、B树。希望各位读者能够关注专题，并给出相应意见，通过系列的学习做到心中有"树"。1 重点概念1.1 结点概念结点是数据结构中的基础，是...
[C/C++]二叉树基础
qq_41221520的博客
07-29 536
二叉树遍历与恢复
二叉树基础函数--C++实现
m0_51808838的博客
05-04 2355
二叉树基础函数--C++实现一、二叉树的先序创建二、二叉树的遍历（1）先序遍历（2）中序遍历（3）后序遍历（4）逐层遍历三、其他应用函数（1）求二叉树的深度（2）复制二叉树（3）统计结点数（4）统计叶子结点数（5）打印从叶子结点到根结点的路径（6）左右结点交换（6）删除结点（7）求位于先序序列中第k个位置的结点的值（8）计算层数节点数四、具体问题(1) 创建哈夫曼树并计算带权路径长度 一、二叉树的先序创建 二叉树的先序创建，首先要构建的根结点，然后依次构建其左孩子和右孩子，根据递归的的思想，孩子结点会再次作
C++二叉树：从基础实现到核心算法解析
lijiale20150909的博客
03-19 587
二叉树的每个节点最多包含两个子节点（左/右），数据域用于存储值。T _data;// 数据域// 左子节点指针// 右子节点指针// 构造函数此结构体支持泛型，适用于不同数据类型。本文系统梳理了C++中二叉树的实现与核心算法，涵盖结构定义、遍历方法、属性计算及实际应用。通过结合递归与非递归实现，读者可深入理解其底层逻辑，并应用于算法优化与复杂系统开发中。
力扣二叉树专题（一）-二叉树理论基础 二叉树的递归遍历 迭代遍历 统一迭代法 前序遍历、中序遍历、后序遍历C++实现
UUUUU22的博客
04-10 582
力扣二叉树专题（上）-二叉树理论基础 二叉树的递归遍历 迭代遍历 统一迭代法 前序遍历、中序遍历、后序遍历C++实现 力扣题144 题94 题145
C++二叉树基础 12.30
sdwsyns的博客
05-26 403
二叉树结构： struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) {} }; 二叉树的遍历方式: 前序序列：根左右 (递归中常用到) 中序序列：左根右 后序序列：左右根 算法相关： （ps:原设定，一棵树只有一个节点或没有节点，它的深度都为0，而这里对于空节点的深度设定为-1，只有一个节点深度设为0） 1.计算二叉树深度 int height
_12LeetCode代码随想录算法训练营第十二天-C++二叉树基础知识 | 144.二叉树的前序遍历、145.二叉树的后序遍历、94.二叉树的中序遍历
Jasmine-Lily的博客
12-20 453
_12LeetCode代码随想录算法训练营第十二天-C++二叉树基础知识 | 144.二叉树的前序遍历、145.二叉树的后序遍历、94.二叉树的中序遍历
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值