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

最新推荐文章于 2024-06-30 20:23:11 发布
最新推荐文章于 2024-06-30 20:23:11 发布
阅读量525 收藏 11
点赞数 13
分类专栏： 程序员 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84185441/article/details/138409547
版权

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


在C/C++语言中，经常使用 NULL 来表示空指针。


NULL在头文件里的定义：

#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif


即在 C++中，NULL 被定义为整形常量 0，而在 C 中，被定义为无类型指针常量 (void\*) 0 。


**C++11标准增加了新的关键字 nullptr，表示空指针。**


建议使用C++11及以上版本的用以下的二叉树声明：

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


### 创建

#include

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;

}


 创建结果：


![](https://img-blog.csdnimg.cn/563563a1125d46588882592e07e0e99f.png)


### 成员运算符->


指向结构体或对象的指针访问其内成员。当一个指针指向一个结构体、对象时，称之为结构体指针或对象指针。结构体指针或对象指针中的值是所指向的结构体或对象的首地址。通过结构体指针或对象指针即可访问该结构体或对象。


结构体指针变量定义的一般形式为：

struct 结构体类型名 *指针名; //结构体指针
struct 结构体类型名 *指针名 = &一个结构体的名字; //结构体指针并赋初值
struct 结构体类型名 *指针名 = new struct 结构体类型名; //结构体指针并用new申请内存
struct 结构体类型名 *指针名 =(struct 结构体类型名 *)malloc(sizeof(struct 结构体类型名))
//结构体指针并用malloc申请内存 使用应包含头文件stdlib.h


子树root->left, root->right 还可以 **.** 运算表示，也是成员运算符。两者的区别：


点运算符 **.** 左边必须用 **\*** 寻址运算符取到指针root指向的结构或者对象实体，如(\*root)；对比箭头状的成员运算符 **->** ，其左边必须为结构体指针，如root。




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


### 批量创建


上例只是创建5节点，如要建更多节点，这样一个一个增加节点写起来复杂；可以用数组或容器等可迭代数据类型批量来创建。


####  完全二叉树的创建




    _______1________
   /                \
__2__             ___3___

/ \ /
4 5 _6 _7
/ \ / \ / \ /
8 9 10 11 12 13 14 15


代码：

#include
#include
using namespace std;

struct TreeNode
{
int val;
TreeNode *left;
TreeNode *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());
vector<TreeNode> q = {root};
int i = 1;
while(!q.empty() && i < nums.size())
{
TreeNode *cur = q.front();
q.assign(q.begin() + 1, q.end());
if(i < nums.size())
{
cur->left = new TreeNode(nums[i++]);
q.push_back(cur->left);
}
if(i < nums.size())
{
cur->right = new TreeNode(nums[i++]);
q.push_back(cur->right);
}
}
return root;
}

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

return 0;

}


创建后，可以用代码把二叉树打印出来以供验证： 


#### 打印二叉树

#include
#include
using namespace std;

struct TreeNode
{
int val;
TreeNode *left;
TreeNode *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());
vector<TreeNode> q = {root};
int i = 1;
while(!q.empty() && i < nums.size())
{
TreeNode *cur = q.front();
q.assign(q.begin() + 1, q.end());
if(i < nums.size())
{
cur->left = new TreeNode(nums[i++]);
q.push_back(cur->left);
}
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());
cout << cur->val << " ";
if(cur->left)
q.push_back(cur->left);
if(cur->right)
q.push_back(cur->right);
}
cout << endl;
}
}

int main()
{
vector nums;
for (int i = 0; i < 15; i++)
nums.push_back(i+1);
TreeNode *root = buildTree(nums);
levelOrderPrint(root);

return 0;

}


**输出：**


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


逐个打印二叉树节点的过程，称为遍历，稍后再讲。


#### 普通二叉树的创建


如下这棵树比上面的树少了3个节点：




    _______1________
   /                \
__2__             ___3___

/ \ /
4 5 _6 7
/ / / \
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


#### 前中后序对比




![img](https://img-blog.csdnimg.cn/img_convert/d06b8130fb1286443d2371d0a7505e91.png)
![img](https://img-blog.csdnimg.cn/img_convert/b4c4018e5ba74ceb9b3569b0719bf509.png)

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

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


**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**

   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

前中后序对比

[外链图片转存中…(img-7AghvBYx-1714697795205)]
[外链图片转存中…(img-FhTKhehG-1714697795205)]

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

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

2401_84185441
关注
  • 13
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
讲解非常详细的C++二叉树的创建与遍历
05-27
讲解非常详细的C++二叉树的创建与遍历 讲解非常详细的C++二叉树的创建与遍历 讲解非常详细的C++二叉树的创建与遍历 讲解非常详细的C++二叉树的创建与遍历 讲解非常详细的C++二叉树的创建与遍历 讲解非常详细的...
二叉树的创建与遍历C语言实现代码.zip
05-27
二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言实现代码.zip二叉树的创建与遍历C语言...
C++实现二叉树的创建和遍历
m0_62367990的博客
12-27 721
实现二叉树的创建和遍历：1、实现二叉树的创建，存储结构为二叉链表结点类型。2、创建后实现先序中序后序的遍历结果。
二叉树的创建与遍历(C++)
zorchp
01-12 1249
-
使用c++实现二叉树的定义、创建、遍历
m0_45906029的博客
01-09 412
使用c++实现二叉树的定义、创建、遍历
c++实现二叉树并遍历
qq_43575504的博客
04-03 1016
Ⅰ 有且只有一个称为根的节点 Ⅱ 有若干个互不相交的子树，这些子树本身也是一棵树 节点、父节点、子节点、子孙、堂兄弟 深度：从根节点到最底层节点的层数，根节点是第一层 叶子节点：没有子节点的节点 非终端节点：非叶子节点 度：子节点的个数 Ⅰ 一般树木：任意一个节点的子节点个数不受限制 Ⅱ 二叉树：任意一个节点的子节点个数最多两个，且子节点位置不可更改 ① 一般二叉树
C++实现的二叉树创建和遍历，超入门邻家小女也懂了
汉阳Hann's Home
03-08 8108
所有层的节点都达到最大数量，叶子除外的所有节点都有两个子节点，所有叶子都在最底一层(k)且数目为2^(k - 1)。如果删除最底一层的所有叶子它就是满二叉树，即除了最后一层，每层节点都达到最大数量 ，即有深度k的个节点数在左闭右开【2^(k-1)+1,2^k-1】区间内。1. 具有N个节点的完全二叉树的深度为[log2 N]+1，其中[x]为高斯函数，截尾取整。（3）若在任意一棵二叉树中，有n0个叶子节点，有n2个度为2的节点，则必有n0=n2+1。（1）如果i=1，则节点i是二叉树的根，无双亲......
C++实现的二叉树创建和遍历，超入门邻家小女也懂了_c++二叉树的建立与遍历(1)
2401_84159911的博客
05-10 661
struct 结构体类型名 *指针名 =(struct 结构体类型名 *)malloc(sizeof(struct 结构体类型名))struct 结构体类型名 *指针名 = new struct 结构体类型名;//结构体指针并用new申请内存。struct 结构体类型名 *指针名 = &一个结构体的名字;//结构体指针并赋初值。(img-WM0UwE2I-1715319437841)]//结构体指针并用malloc申请内存 使用应包含头文件stdlib.h。struct 结构体类型名 *指针名;
C++实现的二叉树创建和遍历，超入门邻家小女也懂了_c++二叉树的建立与遍历(3)
2401_84160041的博客
05-10 574
为了不改变数组的描述，用最小负整数来定义null： #define null INT_MIN增加对空节点的判断 if(i < nums.size() && nums[i]!= null)12 34 5 6 7以上代码，直接用来存放二叉树各节点的指针，queue有队列操作的专用内置方法pop和push，所以要比在前一例中用vector模拟的队列操作要稍微方便一点。注：二叉树的遍历，如用操作的一般是广度优先遍历 （BFS，Breath First Search）而用。
二叉树创建与遍历_二叉树创建与遍历_
09-29
在给定的文件列表中，`源.cpp`可能包含了以上提到的二叉树创建和遍历的代码实现，而`Bitree.h`可能定义了二叉树节点的数据结构。`二叉树创建与遍历.vcxproj`等相关文件是Visual Studio项目文件，用于管理和编译源...
C++实现二叉树非递归遍历方法实例总结
09-04
在C++中，这三种遍历可以通过递归和非递归两种方法实现。本篇文章将重点讨论非递归遍历方法。 非递归遍历通常依赖于栈（stack）数据结构来模拟递归调用的过程，避免了函数调用的开销，并且可以避免深度过大的栈溢出...
c++实现二叉树的创建，遍历，添加，查找与删除
05-27
### C++实现二叉树的创建、遍历、添加、查找与删除资源描述 #### 资源概述 本资源详细介绍了如何使用C++实现二叉树的各种基本操作，包括创建、遍历、添加节点、查找节点和删除节点。这些操作是掌握二叉树数据结构...
【C++】————string基础用法及部分函数底层实现
最新发布
bhbcdxb123的博客
06-30 1000
本文主要介绍STL容器之一 ---- string，在学习C++的过程中，我们要将C++视为一个语言联邦（摘录于Effective C++ 条款一）。如何理解这句话呢，我们学习C++，可将其分为四个板块；分别为C、Object-Oriented C++（面向对象的C++）、Template C++（模板）、STL。本文就介绍STL中的string；1.一个冷知识：屏蔽力是一个人最顶级的能力，任何消耗你的人和事，多看一眼都是你的不对。2.你不用变得很外向，内向挺好的，但需要你发言的时候，一定要勇敢。
《C++ Primer Plus第五版》
风中的默默
06-26 932
连续分段空间,由一段一段的连续空间构成的，用一小块连续的内存空间map作为主控(不是STL的map容器)，里面的每一个元素都是一个指针，指向另一段连续性内存空间，称作缓冲区，默认使用 512 字节大小。假设我们定义一个双向链表，把链表上节点都定义成shared_ptr智能指针，当其中两个节点互相引用的时候，就会出现循环引用的现象。堆是我们通过new关键字来动态申请的内存空间，堆上分配的内存需要我们手动管理，堆是不连续的内存区域，以链表的形式分配的，如果我们没有正确释放堆上的内存可能会出现内存泄漏。
【代码】c++几个常用的函数
一个小学学霸的博客
06-25 1171
c++函数
LeetCode 算法：二叉树的层序遍历 c++
小金牛来了
06-25 764
LeetCode 算法：二叉树的层序遍历 c++
用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、付费专栏及课程。

余额充值