二叉树递归遍历

学习网址;https://leetcode.cn/leetbook/read/data-structure-binary-tree/xe17x7/
二叉树先序遍历 根节点->左节点->右节点
1、容易得到先序遍历中第一个元素一定是根节点数值
2、递归遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
// 遍历二叉树 返回节点的数值，将数值存入数值
    void preorder(TreeNode * root,vector<int> &res){	
        if(root == nullptr) return;
        else{
            res.push_back(root->val);		// 存入根节点的数值
            preorder(root->left,res);			// 遍历左子树
            preorder(root->right,res);		// 遍历右子树
        }
    }
    // 通过preorder函数递归遍历获取容器数值
    vector<int> preorderTraversal(TreeNode* root) {
            vector<int> res;
            preorder(root,res);			// 递归返回list
            return res;
    }
};

中序递归遍历 左节点->父节点->右节点

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
 // 中序遍历先完成 左节点->根节点->右节点
class Solution {
public:
    void inorder(TreeNode * root,vector<int> &res){     // 递归遍历 返回list数值
       if(root == nullptr) return;
       inorder(root->left,res);					// 遍历左子树
       res.push_back(root->val);			// 遍历父节点
       inorder(root->right,res);				// 遍历右子树
    }
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int>res;
        inorder(root,res);
        return res;
    }
};

后续遍历二叉树 左节点->右节点->根节点
后序遍历的过程就是二叉树删除的过程

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
 // 后序遍历 左节点->右节点->父节点
class Solution {
public:
    void postorder(TreeNode *root,vector<int> & res){
        if(root == nullptr) return;
        else{
            postorder(root->left,res);      // 遍历左节点
            postorder(root->right,res);     // 遍历右节点
             res.push_back(root->val);      // 遍历根节点
        }
    }

    vector<int> postorderTraversal(TreeNode* root) {
            vector<int> res;
            postorder(root,res);    // 递归返回list
            return res;
    }
};

二叉树的层遍历 使用队列辅助
在满二叉树的情况下 队列大小size= 1,2,4,8,16…
代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:

    vector<vector<int>> levelOrder(TreeNode* root) {
       if(!root) return  vector<vector<int>>(); // 根节点为空直接返回

       queue<TreeNode*> que;
       vector<vector<int>> res;
       que.push(root);
       while(!que.empty()){
           res.push_back(vector<int>());
           int size = que.size();   // 计算队列的长度 在满二叉树的情况下 入队大小分别为1，2 ，4，8...实现蹭遍历
           for(int i  = 0;i < size;i++){
               TreeNode * cur = que.front();    // 记录当前节点
               que.pop();                       // 该节点出队
               res.back().push_back(cur->val);  
               if(cur->left) que.push(cur->left);   // 如果左节点不为空，左节点入队
               if(cur->right) que.push(cur->right); // 如果右节点不为空，右节点入队
           }
       } 
       return res;
    }
};