1.二叉树的层次遍历

//给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。 
//
// 
//
// 示例 1： 
// 
// 
//输入：root = [3,9,20,null,null,15,7]
//输出：[[3],[9,20],[15,7]]
// 
//
// 示例 2： 
//
// 
//输入：root = [1]
//输出：[[1]]
// 
//
// 示例 3： 
//
// 
//输入：root = []
//输出：[]
// 
//
// 
//
// 提示： 
//
// 
// 树中节点数目在范围 [0, 2000] 内 
// -1000 <= Node.val <= 1000 
// 
//
// Related Topics 树 广度优先搜索 二叉树 👍 1539 👎 0


//leetcode submit region begin(Prohibit modification and deletion)
/**
 * 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 * > qu;
        if (root != NULL) {
            qu.push(root); //root非空我们就将它放到我们的队列的内部

        }
        //定义结果的二维矩阵
        vector <vector<int>> result;
        while (!qu.empty()) {
            int size = qu.size();
            vector<int> vec;//我们定义一个我们的每一层的结果的储存器
            for (int i = 0; i < size; ++i) {
                TreeNode *nodes = qu.front();
                vec.push_back(nodes->val);
                qu.pop(); //取完之后要记得及时的弹出来
                if (nodes->left) {
                    qu.push(nodes->left);
                }
                if (nodes->right) {
                    qu.push(nodes->right);
                }

            }
            result.push_back(vec);


        }
        return result;
    }
};

2.lt107-层次遍历2

//给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历） 
//
// 
//
// 示例 1： 
// 
// 
//输入：root = [3,9,20,null,null,15,7]
//输出：[[15,7],[9,20],[3]]
// 
//
// 示例 2： 
//
// 
//输入：root = [1]
//输出：[[1]]
// 
//
// 示例 3： 
//
// 
//输入：root = []
//输出：[]
// 
//
// 
//
// 提示： 
//
// 
// 树中节点数目在范围 [0, 2000] 内 
// -1000 <= Node.val <= 1000 
// 
//
// Related Topics 树 广度优先搜索 二叉树 👍 639 👎 0


//leetcode submit region begin(Prohibit modification and deletion)
/**
 * 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>> levelOrderBottom(TreeNode *root) {
        //其实本质就是倒序输出层次遍历的结果
        //复习一下层次遍历
        queue < TreeNode * > qu; //我们主体的队列
        //判断树不空的话，我们就把树根节点纳入我们的队列里面
        if (root != NULL) {
            qu.push(root); //树不空，进入我们的队列里面
        }
        vector <vector<int>> result; //储存层序遍历结果二维数组
        while (!qu.empty()) { //只要队列不空我们就要进行遍历
            int size = qu.size(); //这个size来记录我们每一层有多少元素，
            // 来慢慢弹出，不会和其他层搞混
            vector<int> vec; //来存储同一层的元素
            for (int i = 0; i < size; ++i) {
                //将这一层的size个元素来挨个的弹出
                TreeNode *nodes = qu.front();
                vec.push_back(nodes->val);
                qu.pop(); //获取之后，使用完时候就将其弹出队列
                if (nodes->left) { //如果有左孩子或者右孩子的话直接继续加入我们的队列
                    //这样在上一层的时候已经将下一层都放进来了
                    qu.push(nodes->left);
                }
                if (nodes->right) {
                    qu.push(nodes->right);
                }
            }
            result.push_back(vec);

        }
        reverse(result.begin(), result.end());
        return result;


    }
};

3.lt199

//给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。 
//
// 
//
// 示例 1: 
//
// 
//
// 
//输入: [1,2,3,null,5,null,4]
//输出: [1,3,4]
// 
//
// 示例 2: 
//
// 
//输入: [1,null,3]
//输出: [1,3]
// 
//
// 示例 3: 
//
// 
//输入: []
//输出: []
// 
//
// 
//
// 提示: 
//
// 
// 二叉树的节点个数的范围是 [0,100] 
// 
// -100 <= Node.val <= 100 
// 
//
// Related Topics 树 深度优先搜索 广度优先搜索 二叉树 👍 791 👎 0


//leetcode submit region begin(Prohibit modification and deletion)
/**
 * 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> rightSideView(TreeNode *root) {
        //其实就是层次遍历的一个翻版
        queue < TreeNode * > qu;
        if (root != NULL) {
            qu.push(root);
        }

        vector<int> vec;
        while (!qu.empty()) {
            int size = qu.size();

            for (int i = 0; i < size; ++i) {
                TreeNode *nodes = qu.front();
                qu.pop();
                if (i == size - 1) {
                    vec.push_back(nodes->val);
                }
                if (nodes->left) {
                    qu.push(nodes->left);
                }
                if (nodes->right) {
                    qu.push(nodes->right);
                }

            }

        }
        return vec;


    }
};

4.lt637

//给定一个非空二叉树的根节点
// root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10⁻⁵ 以内的答案可以被接受。 
//
// 
//
// 示例 1： 
//
// 
//
// 
//输入：root = [3,9,20,null,null,15,7]
//输出：[3.00000,14.50000,11.00000]
//解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。
//因此返回 [3, 14.5, 11] 。
// 
//
// 示例 2: 
//
// 
//
// 
//输入：root = [3,9,20,15,7]
//输出：[3.00000,14.50000,11.00000]
// 
//
// 
//
// 提示： 
//
// 
// 
//
// 
// 树中节点数量在 [1, 10⁴] 范围内 
// -2³¹ <= Node.val <= 2³¹ - 1 
// 
//
// Related Topics 树 深度优先搜索 广度优先搜索 二叉树 👍 382 👎 0


//leetcode submit region begin(Prohibit modification and deletion)
/**
 * 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<double> averageOfLevels(TreeNode *root) {
        queue < TreeNode * > qu;
        vector<double> result;
        if (root != NULL) {
            qu.push(root);
        }
        while (!qu.empty()) {
            int size = qu.size();
            double sum=0;
            for (int i = 0; i < size; ++i) {
                TreeNode *nodes = qu.front();
                qu.pop();
                sum += nodes->val;
                if (nodes->left) {
                    qu.push(nodes->left);
                }
                if (nodes->right) {
                    qu.push(nodes->right);
                }
            }
            result.push_back(sum / size);
        }
        return result;

    }
};

5.lt429

//给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。 
//
// 树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。 
//
// 
//
// 示例 1： 
//
// 
//
// 
//输入：root = [1,null,3,2,4,null,5,6]
//输出：[[1],[3,2,4],[5,6]]
// 
//
// 示例 2： 
//
// 
//
// 
//输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,
//null,13,null,null,14]
//输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]
// 
//
// 
//
// 提示： 
//
// 
// 树的高度不会超过 1000 
// 树的节点总数在 [0, 10^4] 之间 
// 
//
// Related Topics 树 广度优先搜索 👍 334 👎 0

class Solution {
public:
    vector <vector<int>> levelOrder(Node *root) {
        //N叉树的遍历其实本质上还是模板题
        queue < Node * > qu;
        if (root != NULL) {
            qu.push(root);
        }
        vector <vector<int>> result;
        while (!qu.empty()) {
            int size = qu.size();
            vector<int> vec;
            for (int i = 0; i < size; ++i) {
                Node *nodes = qu.front();
                qu.pop();
                vec.push_back(nodes->val); //将数值先存下来
                for (int j = 0; j < nodes->children.size(); ++j) {
                    if (nodes->children[j]) {
                        qu.push(nodes->children[j]);
                    }
                }

            }
            result.push_back(vec);

        }
        return result;


    }
};

lt101

//给你一个二叉树的根节点 root ， 检查它是否轴对称。 
//
// 
//
// 示例 1： 
// 
// 
//输入：root = [1,2,2,3,4,4,3]
//输出：true
// 
//
// 示例 2： 
// 
// 
//输入：root = [1,2,2,null,3,null,3]
//输出：false
// 
//
// 
//
// 提示： 
//
// 
// 树中节点数目在范围 [1, 1000] 内 
// -100 <= Node.val <= 100 
// 
//
// 
//
// 进阶：你可以运用递归和迭代两种方法解决这个问题吗？ 
//
// Related Topics 树 深度优先搜索 广度优先搜索 二叉树 👍 2224 👎 0


//leetcode submit region begin(Prohibit modification and deletion)
/**
 * 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:
    bool compare(TreeNode *left, TreeNode *right) {
        //首先我们先确定我们递归的终止的条件
        if (left == NULL && right != NULL) {
            return false;
        } else if (left != NULL && right == NULL) {
            return false;
        } else if (left == NULL && right == NULL) {
            return true;
        } else if (left->val != right->val) {
            return false;
        }
        //其次我们就要进行我们的下一层的递归
        //通过上面的代码我们已经可以确定，
        // 目前这一层的代码是相同的了，我们还是要判断下一层的代码是否是相同的
        bool outside = compare(left->left, right->right);
        bool inside = compare(left->right, right->left);
        bool ist = outside && inside;
        return ist;


    }

    bool isSymmetric(TreeNode *root) {
        if (root == NULL) {
            return true;
        }
        return compare(root->left, root->right);


    }
};