C++实现的二叉树创建和遍历，超入门邻家小女也懂了_c++二叉树的建立与遍历int main() { } struct

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://p3-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/b8389794c2284b6396c26a33da8e92b2~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAg5py65Zmo5a2m5Lmg5LmL5b-DQUk=:q75.awebp?rk3s=f64ab15b&x-expires=1771262029&x-signature=%2FjUQ0Uiz1UztI%2FNh0I1JIjPpVIg%3D)


### 成员运算符->


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


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

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

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://p3-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/3fdb35e4b7134defbcb430c26b3fbf02~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAg5py65Zmo5a2m5Lmg5LmL5b-DQUk=:q75.awebp?rk3s=f64ab15b&x-expires=1771262029&x-signature=YfwbVLsEnLXaE37NQvk3ryRXpLU%3D)


层序遍历的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) {} };

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://p3-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/dcc3d51eb8af4719ac0d4f1309c0095e~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAg5py65Zmo5a2m5Lmg5LmL5b-DQUk=:q75.awebp?rk3s=f64ab15b&x-expires=1771262029&x-signature=vm1Mb3tV9WMmu9FM2yh0a6IIE4c%3D)


### 中序遍历


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


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


![](https://p3-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/78d85fadef2d477a985c83af406b383c~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAg5py65Zmo5a2m5Lmg5LmL5b-DQUk=:q75.awebp?rk3s=f64ab15b&x-expires=1771262029&x-signature=aMp1OfQJdjh0zz%2F7rUrR%2B9zcLFU%3D)


### 后序遍历


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


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


![](https://p3-xtjj-sign.byteimg.com/tos-cn-i-73owjymdk6/7ad2fb4d18cb43b6ad66e4ad9d59b837~tplv-73owjymdk6-jj-mark-v1:0:0:0:0:5o6Y6YeR5oqA5pyv56S-5Yy6IEAg5py65Zmo5a2m5Lmg5LmL5b-DQUk=:q75.awebp?rk3s=f64ab15b&x-expires=1771262029&x-signature=JM49Nlwfhr0FlGlpYxb2qOYVYm8%3D)


#### 递归法

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

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

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

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

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

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