C++实现的二叉树创建和遍历，超入门邻家小女也懂了_c++二叉树的建立与遍历

于 2024-04-28 18:02:55 发布
阅读量884 收藏 11
点赞数 9
分类专栏： 程序员 文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61549984/article/details/138286554
版权

/ / / \
8 10 12 13 15


空结点一般用null描述，如：{1,2,3,4,5,6,7,8,null,10,11,null,13,null,15}。


为了不改变数组的描述，用最小负整数来定义null： #define null INT\_MIN


**代码：**


增加对空节点的判断 if(i < nums.size() && nums[i] != null)

#include
#include
#include
#define null INT_MIN
using namespace std;

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

TreeNode* buildTree(vector& nums)
{
if (nums.empty()) return nullptr;
TreeNode root = new TreeNode(nums.front());
queue<TreeNode> q;
q.push(root);
int i = 1;
while(!q.empty() && i < nums.size())
{
TreeNode *cur = q.front();
q.pop();
if(i < nums.size() && nums[i] != null)
{
cur->left = new TreeNode(nums[i]);
q.push(cur->left);
}
i++;
if(i < nums.size() && nums[i] != null)
{
cur->right = new TreeNode(nums[i]);
q.push(cur->right);
}
i++;
}
return root;
}

void levelOrder(TreeNode* root)
{
if(!root) return;
queue<TreeNode*> q;
q.push(root);
while(!q.empty())
{
int size = q.size();
for(int i = 0; i < size; i++)
{
TreeNode *cur = q.front();
q.pop();
cout << cur->val << " ";
if(cur->left)
q.push(cur->left);
if(cur->right)
q.push(cur->right);
}
cout << endl;
}
}

int main()
{
vector nums = {1,2,3,4,5,6,7,8,null,10,11,null,13,null,15};
TreeNode *root = buildTree(nums);
levelOrder(root);

return 0;

}


**输出：**


1  
 2 3  
 4 5 6 7  
 8 10 11 13 15


以上代码，直接用**队列 queue**来存放二叉树各节点的指针，queue有队列操作的专用内置方法pop和push，所以要比在前一例中用vector模拟的队列操作要稍微方便一点。


注：二叉树的遍历，如


用**队列**操作的一般是广度优先遍历 （BFS，Breath First Search）


而用**栈**操作的一般是深度优先遍历 （DFS，Depth First Search）




---


## 二叉树的遍历


指如何按某种搜索路径巡防树中的每个结点，使得每个结点均被访问一次，而且仅被访问一次。  
 常见的遍历方法有：**层序遍历，先序遍历，中序遍历，后序遍历**。


### 层序遍历


若二叉树为空，为空操作；否则从上到下、从左到右按层次进行访问。


遍历结果： 1 [2 3] [4 5 6 7] [8 9 10 11 12 13 14 15]  
![](https://img-blog.csdnimg.cn/20210725085538742.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JveXNvZnQyMDAy,size_16,color_FFFFFF,t_70)


层序遍历的BFS代码在上面的**打印二叉树**章节已放出，这里放上我见过的一种用递归法写的二叉树层序遍历：

#include
#include
#include
#define null INT_MIN
using namespace std;

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

TreeNode* buildTree(vector& nums)
{
if (nums.empty()) return nullptr;
TreeNode root = new TreeNode(nums.front());
queue<TreeNode> q;
q.push(root);
int i = 1;
while(!q.empty() && i < nums.size())
{
TreeNode *cur = q.front();
q.pop();
if(i < nums.size() && nums[i] != null)
{
cur->left = new TreeNode(nums[i]);
q.push(cur->left);
}
i++;
if(i < nums.size() && nums[i] != null)
{
cur->right = new TreeNode(nums[i]);
q.push(cur->right);
}
i++;
}
return root;
}

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);
}

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

void levelOrder(TreeNode* root)
{
int level = 0;
while(true)
{
int cnt = countNodesAtLevel(root, level);
if(cnt == 0) break;
for(int i = 0; i < cnt; i++)
{
TreeNode *node = getNodeAtLevel(root, level, i);
cout << node->val << " ";
}
cout << endl;
level++;
}
}

int main()
{
vector nums = {1,2,3,4,5,6,7,8,null,10,11,null,13,null,15};
TreeNode *root = buildTree(nums);
levelOrder(root);

return 0;

}


### 先序遍历


若二叉树为空，为空操作；  
 否则（1）访问根节点；（2）先序遍历左子树；（3）先序遍历右子树。


遍历结果： 1 [2 [4 8 9] [5 10 11]] [3 [6 12 13] [7 14 15]   “**根左右**”


![](https://img-blog.csdnimg.cn/20210725082352964.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JveXNvZnQyMDAy,size_16,color_FFFFFF,t_70)


### 中序遍历


若二叉树为空，为空操作；  
 否则（1）中序遍历左子树；（2）访问根结点；（3）中序遍历右子树。


遍历结果： [[8 4 9] 2 [10 5 11]] 1 [[12 6 13] 3 [14 7 15]]  “**左根右**”


![](https://img-blog.csdnimg.cn/20210725083710482.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JveXNvZnQyMDAy,size_16,color_FFFFFF,t_70)


### 后序遍历


若二叉树为空，为空操作；  
 否则（1）后序遍历左子树；（2）后序遍历右子树；（3）访问根结点。


遍历结果： [[8 9 4] [10 11 5] 2] [[12 13 6] [14 15 7] 3] 1  “**左右根**”


![](https://img-blog.csdnimg.cn/20210725084708331.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JveXNvZnQyMDAy,size_16,color_FFFFFF,t_70)


#### 递归法

#include
#include
#include
#define null INT_MIN
using namespace std;

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

TreeNode* buildTree(vector& nums)
{
if (nums.empty()) return nullptr;
TreeNode root = new TreeNode(nums.front());
queue<TreeNode> q;
q.push(root);
int i = 1;
while(!q.empty() && i < nums.size())
{
TreeNode *cur = q.front();
q.pop();
if(i < nums.size() && nums[i] != null)
{
cur->left = new TreeNode(nums[i]);
q.push(cur->left);
}
i++;
if(i < nums.size() && nums[i] != null)
{
cur->right = new TreeNode(nums[i]);
q.push(cur->right);
}
i++;
}
return root;
}

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 main()
{
vector nums;
for (int i = 0; i < 15; i++)
nums.push_back(i+1);
TreeNode *root = buildTree(nums);
preOrderTraversal(root);
cout << endl;
inOrderTraversal(root);
cout << endl;
postOrderTraversal(root);
cout << endl;

return 0;

}


**输出：**


1 2 4 8 9 5 10 11 3 6 12 13 7 14 15  
 8 4 9 2 10 5 11 1 12 6 13 3 14 7 15  
 8 9 4 10 11 5 2 12 13 6 14 15 7 3 1


#### 前中后序对比


遍历时核心代码的顺序是关键，就是上面讲过的用“**根左右**”“**左根右**”“**左右根**”记忆，看根节点的左右子树节点的位置比较：



> 
> **根左右——前序**  
>      cout << root->val << " ";  
>      preOrderTraversal(root->left);  
>      preOrderTraversal(root->right);
> 
> 
> **左根右——中序**  
>      inOrderTraversal(root->left);  
>      cout << root->val << " ";  
>      inOrderTraversal(root->right);
> 
> 
> **左右根——后序**  
>      postOrderTraversal(root->left);  
>      postOrderTraversal(root->right);  
>      cout << root->val << " ";
> 
> 
> 


遍历除了直接打印节点外，还可以把各节点值域存入数组，以中序为例：

vector inorderTraversal(TreeNode* root) {
vector res;
inorderTraversal(root, res);
return res;
}
void inorderTraversal(TreeNode* root, vector& res) {
if (root == nullptr) {
return;
}
inorderTraversal(root->left, res);
res.push_back(root->val);
inorderTraversal(root->right, res);
}




---


#### DFS遍历


DFS会用到<stack>，直接打印版：

#include
#include
#include
#include
#define null INT_MIN
using namespace std;

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

TreeNode* buildTree(vector& nums)
{
if (nums.empty()) return nullptr;
TreeNode root = new TreeNode(nums.front());
queue<TreeNode> q;
q.push(root);
int i = 1;
while(!q.empty() && i < nums.size())
{
TreeNode *cur = q.front();
q.pop();
if(i < nums.size() && nums[i] != null)
{
cur->left = new TreeNode(nums[i]);
q.push(cur->left);
}
i++;
if(i < nums.size() && nums[i] != null)
{
cur->right = new TreeNode(nums[i]);
q.push(cur->right);
}
i++;
}
return root;
}

void preOrderTraversal(TreeNode* root) {
stack<TreeNode*> st;
TreeNode* node = root;
while (node != nullptr || !st.empty()) {
while (node != nullptr) {
cout << node->val << " ";
st.push(node);
node = node->left;
}
node = st.top();
st.pop();
node = node->right;
}
}

void inOrderTraversal(TreeNode* root) {
stack<TreeNode*> st;
TreeNode* node = root;
while (node != nullptr || !st.empty()) {
while (node != nullptr) {
st.push(node);
node = node->left;
}
node = st.top();
st.pop();
cout << node->val << " ";
node = node->right;
}
}

void postOrderTraversal(TreeNode* root) {
stack<TreeNode*> st;
TreeNode* node = root;
TreeNode* last = nullptr; // 上一次访问的节点
while (node != nullptr || !st.empty()) {
while (node != nullptr) {
st.push(node);
node = node->left;
}
node = st.top();
if (node->right == nullptr || node->right == last) {
// 右子树为空或已经访问过
cout << node->val << " ";
st.pop();
last = node; // 更新上一次访问的节点
node = nullptr; // 继续弹出栈顶元素
} else { // 右子树还未访问
node = node->right;
}
}
}

int main()
{
vector nums;
for (int i = 0; i < 15; i++)
nums.push_back(i+1);
TreeNode *root = buildTree(nums);
preOrderTraversal(root);
cout << endl;
inOrderTraversal(root);
cout << endl;
postOrderTraversal(root);
cout << endl;

return 0;

}


二叉树转数组，分别用DFS,BFS实现：

vector DFSinorderTraversal(TreeNode* root) {
vector res;
stack<TreeNode*> st;
while (root != nullptr || !st.empty()) {
while (root != nullptr) {
st.push(root);
root = root->left;
}
root = st.top();
st.pop();
res.push_back(root->val);
root = root->right;
}
return res;
}

vector BFSinorderTraversal(TreeNode* root) {
vector res;
queue<TreeNode*> q;
if (root != nullptr) {
q.push(root);
}
while (!q.empty()) {
TreeNode* node = q.front();
q.pop();
if (node->left != nullptr) {
q.push(node->left);
}
res.push_back(node->val);
if (node->right != nullptr) {
q.push(node->right);
}
}
return res;
}




---


## **树的相关术语**


**节点**：包含一个数据元素及若干指向其子树的分支，又的译成“**结点**”（Node）  
**根**：树和子树的“顶点”（Root）  
**度**：节点拥有的子树数量称为**节点的度**（Degree）；**树的度**是指树内个结点的度的最大值  
**分支节点**：度不为0的节点  
**叶子**：没有子树的节点，即它的度为0 （Leaf）  
**子节点**：结点的子树的根称为该节点的**孩子**（Child）  
**父节点**：对应子节点上一层(level)节点称为该节点的**双亲**（Parent）  
**兄弟结点**：同一父节点的子节点，互称**兄弟**（Sibling）  
 节点的**祖先**：是从根到该结点所经分支上的所有节点  
 节点的**子孙**：以某结点为根的子树中的所有节点  
**层**：从根开始，根为第一层，根的孩子为第二层...（Level）  
**深度**：树中结点的最大层次数，称为树的深度或高度 （Depth or Height）  
**森林**：是很多互不相交的树的集合（Forest）


**无序树**：树中任意节点的子节点之间没有顺序关系，这种树称为无序树，也称为自由树  
**有序树**：树中任意节点的子节点之间有顺序关系，这种树称为有序树  
**最大树（最小树）**：每个结点的值都大于（小于）或等于其子结点（如果有的话）值的树




---


## 特殊二叉树


### 满二叉树


所有层的节点都达到最大数量，叶子除外的所有节点都有两个子节点，所有叶子都在最底一层(k)且数目为2^(k - 1)。即深度k且有2^k - 1个节点(叶子“长”满最后一层)，或称完美二叉树 （Perfect Binary Tree）




     ______12_______
    /               \
 __3__             __5__
/     \           /     \

_7 6 _9 11
/ \ / \ / \ /
13 8 1 4 10 2 0 14


### 完全二叉树


如果删除最底一层的所有叶子它就是满二叉树，即除了最后一层，每层节点都达到最大数量 ，即有深度k的个节点数在左闭右开【2^(k-1)+1,2^k-1】区间内。（Complete Binary Tree）




     ________3______
    /               \
___11___           __4__

/ \ /
14 7 9 13
/ \ / \ /
2 5 8 6 1



### 最后

不知道你们用的什么环境，我一般都是用的Python3.6环境和pycharm解释器，没有软件，或者没有资料，没人解答问题，都可以免费领取（包括今天的代码），过几天我还会做个视频教程出来，有需要也可以领取~  

给大家准备的学习资料包括但不限于：  

Python 环境、pycharm编辑器/永久激活/翻译插件  

python 零基础视频教程  

Python 界面开发实战教程  

Python 爬虫实战教程  

Python 数据分析实战教程  

python 游戏开发实战教程  

Python 电子书100本  

Python 学习路线规划

![](https://img-blog.csdnimg.cn/d29631674929476f9c3b30f7ff58dff0.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ZlaTM0Nzc5NTc5MA==,size_16,color_FFFFFF,t_70)




**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化学习资料的朋友，可以戳这里无偿获取](https://bbs.csdn.net/topics/618317507)**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**
洪湖顶级程序员
关注
  • 9
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树建立与遍历 c++版本
06-02
C++实现二叉树的建立与遍历，简单易懂！！！
二叉树各种遍历算法的C++实现
05-19
包括了二叉树的各种递归与非递归的遍历算法 还可对二叉树所有结点求和
二叉树建立及遍历算法实现
06-03
建立二叉树，实现二叉树的先序、中序、后序的递归遍历算法，输出遍历结果。 实现二叉树的先序、中序、后序和层次遍历的非递归算法，输出遍历结果。
满二叉树的前序遍历C++实现
06-05
对于满二叉树，其每个非叶子节点都有两个子节点。因此，满二叉树的前序遍历、中序遍历和后序遍历均可以通过递归方式实现。 以前序遍历为例，满二叉树的前序遍历顺序为：根、左、右。 在具体实现过程中，我们可以通过构造一个满二叉树，然后进行前序遍历来获取遍历结果。以深度为 3 的满二叉树为例，它的前序遍历结果为：1、2、4、5、3、6、7。 将这个满二叉树放置在平面直角坐标系中，可以发现每个节点的坐标可以通过一些简单的数学运算得到。例如，对于深度为 depth 且在第 i 层（从根节点开始计数）的节点，其坐标为 (i, j)，其中 j = pow(2, depth - i) + i - 1。 根据计算出来的坐标，我们可以轻松地将这棵满二叉树构造出来，并以前序遍历方式输出其遍历结果。
数据结构C++二叉树的先序遍历、中序遍历和后序遍历实现
12-06
数据结构C++二叉链表的先序遍历、中序遍历和后序遍历实现
二叉树创建与遍历_二叉树创建与遍历_
09-29
二叉树的创建与遍历，使用递归调用，含前序遍历、中序遍历、后序遍历、层序遍历
C++实现二叉树非递归遍历方法实例总结
09-04
主要介绍了C++实现二叉树非递归遍历方法实例总结,是算法设计中比较经典的一个遍历算法,需要的朋友可以参考下
二叉树_C++_二叉树遍历_Vc_
09-29
采用二叉链表作为存储结构，完成二叉树的建立，前序、中序和后序遍历的操作，求所有叶子及结点总数的操作等。具体实现要求：分别利用前序遍历、中序遍历、后序遍历所建二叉树。
基于C++实现二叉树的创建，遍历，添加，查找与删除
最新发布
04-24
二叉树的创建与遍历 基于C++实现二叉树的创建，遍历，添加，查找与删除
erchashu.rar_二叉树_二叉树遍历_完全遍历_树型结构_树结构
09-22
该软件主要是利用完全二叉树的性质建立一棵二叉树，然后运用二叉链表与栈对二叉树进行复合操作，并实现各种功能。具体包括建立二叉树、遍历二叉树、求二叉树的深度、求二叉树的叶子结点。其中遍历二叉树包含三种方法...
[C++]二叉树的建立和遍历
06-08
实验目的： (1)进一步掌握指针变量的使用。 (2)掌握_一叉树的结构特征以及各种存储结构的特点及使用范围。 (3)掌握用指针类型描述、访问和处理二叉树的运算。 (4)掌握栈或队列的使用。
C++实现二叉树遍历序列的求解方法
09-04
主要介绍了C++实现二叉树遍历序列的求解方法,需要的朋友可以参考下
数据结构实验——二叉树的建立和遍历.zip
12-13
1.采用二叉链表作为存储结构，创建一棵二叉树； 2.用递归及非递归算法对二叉树实现先序遍历； 3.用递归及非递归算法对二叉树实现中序遍历； 4.用递归及非递归算法对二叉树实现后序遍历。 5.用递归遍历算法中的访问...
Project2_二叉树_先序遍历_后序遍历_中序遍历_
10-04
此程序用于二叉树的建立以及中序、先序、后序遍历
二叉树的层次遍历(python&C++)
06-07
二叉树的层次遍历，思路与实现
C++版二叉树的创建与遍历
qq_48988844的博客
09-08 3087
使用补空法创建了一棵二叉树，并且实现了先序遍历、中序遍历、后序遍历、层次遍历功能。 1、定义结点类： 要创建二叉树首先要定义二叉树的结点类，二叉树上每一个结点有3个成员变量，一个存放当前结点的值，其余两个是指针类型，分别指向此节点的左孩子和右孩子； class Node { public: char data; Node* lchild; //指向左孩子 Node* rchild; //指向右孩子 }; using Tree = Node*; 2、使用补空法创
C++实现二叉树的创建以及四种遍历方式（递归与非递归）
weixin_42133358的博客
05-23 4542
C++实现二叉树的创建以及四种遍历方式（递归与非递归） 语言这个东西不用真的会忘， 我记得前前后后C++的基本语法我也看了好几遍了，一直没有动手写过什么东西，所以一遍遍的看，一遍遍的忘… … 正好最近在看数据结构，想着自己用C++来实现一下，一方面是熟悉整个逻辑过程，加深对数据结构的理解，另一方面，也熟悉一下C++。 下图是我们要创建的二叉树，其中的#代表空字符； 为了验证我们程序的正确性，现给出此二叉树的四种遍历结果： 前序遍历（Preorder traversal）： A B C D E F
C++二叉树及遍历方式
qq_49209946的博客
03-16 481
PS：前中后序的递归版本代码非常的简单，所以如果有能力的情况下，最好还是学会迭代版本，其原理是利用了栈结构的先入后出的原则，实现了前中后序遍历，而层序遍历则利用了队列的先入先出原则实现，这个需要特别的注意一下，上面的代码可以直接当做模板。其中层序遍历最好理解，就是将二叉树从根节点向下，一层一层遍历出来，遍历出来的结果就是一个二维数组，一维长度就是数的高度，二维长度就是每层的节点的个数。（有一个很好记的方法，就是记根节点的位置，在前就是前序，在中就是中序，在后就是后续，因为左右的相对顺序是不会变的）
C++ 二叉树(建立、销毁、前中后序遍历和层次遍历，寻找双亲结点等)
呵呵哒!的博客
08-15 442
（8）获取结点，判断其是否在二叉树中。（9）计算结点个数和获取结点个数。（3）前中后序遍历和层序遍历。
用c++实现二叉树的先序遍历和层次遍历
06-09
好的，下面是用C++实现二叉树的先序遍历和层次遍历的代码： ```c++ #include #include using namespace std; // 二叉树的节点结构体 struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值