代码随想录Day13_二叉树1

144. 二叉树的前序遍历 - 力扣（LeetCode）  递归

class Solution {
public:
void traversal(TreeNode* curr,vector<int> &vec){
    if(curr==NULL)   return;
    vec.push_back(curr->val);
    traversal(curr->left,vec);
    traversal(curr->right,vec);
}
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        traversal(root,res);
        return res;

    }
};

写法：

1.先确定参数和返回值；

2.确定终止条件；

3.确定每一层的循环逻辑。

145. 二叉树的后序遍历 - 力扣（LeetCode）     迭代

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> st;
        if (root == NULL)  return res;
            st.push(root);//root->val？里面保存的是指针类型数据，不是int类型数据，放的不是值。
        while(!st.empty()) {
            TreeNode* node = st.top();
            st.pop();
            res.push_back(node->val);
            if(node->left) st.push(node->left);
            if(node->right) st.push(node->right);
        }
        reverse(res.begin(), res.end());
        return res;
    }
};

思路：迭代法是通过一个栈和一个动态数组实现二叉树的遍历。其中，栈用来模拟每一个节点的情况，存储节点指针，数组用来储存遍历出来的值。

整体逻辑是：

1.初始化（根入栈）

2.循环：弹出栈顶；压入左、右。

 102. 二叉树的层序遍历 - 力扣（LeetCode）

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;//vector<int> vec;放这里输出是会把每一层序都输出？
        vector<vector<int>> res;
        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);
            }
            res.push_back(vec);
        } 
       return res; 
    }
};

思路： 

层序遍历，如果一层的全走了，那么下一层的就没有索引的方法了，所以一定是要上一层走的时候，要把相关的下一层放进去。以此作为循环的主体。如此一来差辈了，所以要把上一辈的个数先记下来。队列内：node是谁，弹出并进入数组，左、右进来队列。

结构：一个队列，一个二维数组。队列放指针，数组放每一层的结果。

637. 二叉树的层平均值 - 力扣（LeetCode）

 (从这一题才意识到)在外面这个判断(队列不为空时)，队列的大小就是每一层的个数

进入循环是存在差辈的情况的，此时队列的大小没有意义。

class Solution {
public:
    vector<double> averageOfLevels(TreeNode* root){
        queue<TreeNode*> que;
        vector<double> res;
        if (root != NULL)
            que.push(root);
        while (!que.empty()) {
            int size = que.size();
            double sum=0;
            vector<int> vec;
            for (int i=0;i<size;i++) {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                sum+=node->val;
                if (node->left)
                    que.push(node->left);
                if (node->right)
                    que.push(node->right);
            }
            res.push_back(sum/size);
            // int vsize =vec.size();
            // double sum=0;
            // for(int i=0;i<vsize;i++)
            // sum+=vec[i];
            // double ave =sum/vsize;
            // res.push_back(ave);

        }
        return res;
    }
};