[代码随想录打卡Day13] 理论基础 递归遍历 （必须掌握） 迭代遍历 （基础不好的录友，迭代法可以放过） 统一迭代 （基础不好的录友，迭代法可以放过） 层序遍历

理论基础

主要是二叉树的种类：满二叉树，完全二叉树（底层节点连续），二叉搜索树（节点上的元素要有顺序，不要求结构），平衡二叉搜索树（左子树和右子树的高度绝对值不超过1）。
存储方式：链式、线性
二叉树的遍历：：

1. 深度优先遍历（递归实现），例如：前序中序后序。（递归法、迭代法 栈）
2. 广度优先遍历：层序遍历 迭代法 队列

每一种用递归地方法都可以用相应的迭代法来解决。
二叉树的定义。（C++, JAVA, Python）

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

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode() {}
    TreeNode(int val) { this.val = val; }
    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

class TreeNode:
    def __init__(self, val, left = None, right = None):
        self.val = val
        self.left = left
        self.right = right

递归遍历 （必须掌握）

递归：

1. 确定递归函数的参数和返回值。
2. 确定终止条件。
3. 确定单层递归的逻辑。
   一般二叉树的递归函数的参数是根节点+数组（存放结果）。返回值是void，因为结果存放在参数中。
   下面是前序遍历的C++,JAVA和Python代码。
   前序遍历：中左右
   中序遍历：左中右
   后序遍历：左右中
   在使用递归进行遍历的时候只需要将中、左、右单次递归的三行代码调换顺序就可以。

/**
 * 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 traversal(TreeNode* cur, vector<int>& vec){//参数和返回值，对应1，注意这个里面有个&//&表示该参数是以引用（reference）的方式传递的，而不是按值传递。
        if(cur == NULL) return;//终止条件 对应2
        vec.push_back(cur->val);//中 下面这三行是单层递归的逻辑 对应3
        traversal(cur->left, vec);//左
        traversal(cur->right, vec);//右
    }
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        traversal(root, result);
        return result;
    }
};

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root){
        List<Integer> result = new ArrayList<Integer>();//这个就是定义一个list来存储最终结果
        preorder(root, result);
        return result;
    }
    public void preorder(TreeNode root, List<Integer> result) {//参数和返回值
        if(root == null){
            return;//终止条件
        }
        result.add(root.val);//中
        preorder(root.left, result);//左
        preorder(root.right, result);//右
    }
}

# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution(object):
    def preorderTraversal(self, root):
        """
        :type root: Optional[TreeNode]
        :rtype: List[int]
        """
        res = []#这个作用域在函数内，起始和C++和JAVA传入递归函数相同
        def dfs(node):
            if node is None:
                return 
            res.append(node.val)
            dfs(node.left)
            dfs(node.right)
        dfs(root)
        return res

迭代遍历 （基础不好的录友，迭代法可以放过）

前序遍历：中左右。

遍历和处理节点的顺序是相同的。
递归法就是使用栈实现的。相应递归法的迭代法也是使用栈来实现。
具体来说，如下图所示。
前序遍历遍历和处理的节点的顺序相同。

class Solution {
public:
    //这个是迭代法
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;//定义一个栈进行迭代
        vector<int> result; //存储最终结果
        st.push(root);
        while(!st.empty()){
            TreeNode* node = st.top();st.pop();
            if(node!=NULL) result.push_back(node->val);
            else continue;
            st.push(node->right);
            st.push(node->left);
        }
        return result;
    }
};

中序遍历：左中右

中序遍历遍历节点的顺序和处理节点的顺序是不一样的。
使用指针遍历节点，使用栈来记录遍历过的节点。从栈里弹出元素记录到result数组中。
具体如下图所示。

/**
 * 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<int> inorderTraversal(TreeNode* root){
        vector<int> result;
        stack<TreeNode*> st;
        TreeNode* cur = root;
        while(cur!=NULL || !st.empty()){
            if(cur != NULL){//指针来访问节点
                st.push(cur);//将访问的节点放进栈
                cur = cur -> left;//左，一直到最左边
            } else {
                cur = st.top();//如果指针为空就从栈中弹出元素
                st.pop();
                result.push_back(cur->val);//中
                cur = cur->right;//赋值为它的右孩子继续迭代

            }
        }
        return result;
    }
};

后序遍历左右中

可以对前序遍历的代码进行修改，改变左右孩子入栈的顺序，变成中右左，然后对得到的数组进行反转就可以。

/**
 * 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<int> postorderTraversal(TreeNode* root){
        stack<TreeNode*> st;
        vector<int> result;
        if(root == NULL) return result;
        st.push(root);//
        while(!st.empty()){
            TreeNode* node = st.top();
            st.pop();
            result.push_back(node->val);
            if (node->left) st.push(node->left);
            if (node->right) st.push(node->right);//这个就不存入null了
        }
        reverse(result.begin(), result.end());//结果进行反转之后就是左右中的顺序了
        return result;
    }
};

统一迭代 （基础不好的录友，迭代法可以放过）

我放过了。。。

层序遍历

使用队列实现。注意设置一个size来记录每一层节点的数量，然后控制队列中弹出的节点的数量。具体如下图所示。

/**
 * 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) {
        queue<TreeNode*> que;
        vector<vector<int>> result;
        if(root!=NULL) que.push(root);
        while(!que.empty()){
            int size = que.size();
            
            vector<int> vec;
            while(size--){
                TreeNode* node = que.front(); que.pop();
                vec.push_back(node->val);
                if(node->left){
                    que.push(node->left);
                }
                if(node->right){
                    que.push(node->right);
                }
            }
            result.push_back(vec);
        }
        return result;
    }
};