day 15：第六章 二叉树 part02

总结

主要学习了层序遍历（1.借助队列迭代。2.递归）

● 层序遍历 10
十道题，均可用层序遍历的思想完成（1.借助队列迭代。2.递归）
● 226.翻转二叉树
我使用的层序遍历的方法对左右节点进行反转，还可以使用递归，递归的时候需要注意用何种顺序进行遍历
● 101.对称二叉树 2
本质上是要对左右子树分别遍历，并且遍历顺序相反，借助递归法实现

● 层序遍历 10
102.二叉树的层序遍历

/*102. 二叉树的层序遍历
    中等
给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。*/

/**
 * 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_102 {
 public:
  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) {}
  };

  /*
   * 怎么判断哪些结点是同一层的
   * 或者说怎么获取一层结点
   * 把每层节点压入队列，每次循环读一整层节点，就不需要判断该节点是哪层的了，也拿到了一层所有节点
   * 第二种方法，递归，把遍历每一层当一次递归逻辑，为空则是终止条件
   */
  vector<vector<int>> levelOrder(TreeNode* root) {
      vector<vector<int>> res;
      if(!root)
          return res;
      queue<TreeNode*> record;
      record.push(root);
      while (!record.empty()){
          vector<int> temp;
          int size = record.size();
          while (size--) {
              TreeNode *node = record.front();
              temp.push_back(node->val);
              record.pop();
              if (node->left)
                  record.push(node->left);
              if (node->right)
                  record.push(node->right);
          }
          res.push_back(temp);
      }
      return res;
  }

  void order(int depth, TreeNode* node, vector<vector<int>> &vec){
      if(!node)
          return;
      if(depth >= vec.size())//多维数组需要初始化
          vec.push_back(vector<int>());
      vec[depth].push_back(node->val);
      if(node->left)
          order(depth + 1, node->left, vec);
      if(node->right)
          order(depth + 1, node->right, vec);
  }

  vector<vector<int>> levelOrder_di_gui(TreeNode* root) {
      vector<vector<int>> res;
      int depth = 0;
      order(depth, root, res);
      return res;
  }
};

107.二叉树的层次遍历II

/*
 * 107. 二叉树的层序遍历 II
中等
给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）
 */

/**
 * 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_107 {
 public:
  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) {}
  };
  /*
   * 102 层序遍历反转下结果就行
   * 两种方法，队列，递归
   */
  void order(int depth, TreeNode* node, vector<vector<int>> &vec){
      if(!node)
          return;
      if(depth >= vec.size())//多维数组需要初始化
          vec.push_back(vector<int>());
      vec[depth].push_back(node->val);
      if(node->left)
          order(depth + 1, node->left, vec);
      if(node->right)
          order(depth + 1, node->right, vec);
  }
  vector<vector<int>> levelOrderBottom(TreeNode* root) {
      vector<vector<int>> res;
      int depth = 0;
      order(depth, root, res);
      auto itr_b = res.begin();
      auto itr_e = res.end();
      //reverse(itr_b, itr_e);
      while (itr_b != itr_e && itr_b != --itr_e){//首先--itr_e保证尾迭代器不指向空,其次保证不会有指向同一个元素时因为--，++而错过导致无限迭代
          swap(*itr_b, *itr_e);//解引用，否则交换的是两个指针的内容，而不是指针指向的内容
          ++itr_b;
      }
      return res;
  }
};

199.二叉树的右视图

/*199. 二叉树的右视图
    中等
给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。*/

/**
 * 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_199 {
 public:
  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) {}
  };
/*
 * 102 层序遍历的思路，只需要跳过该层前面的值拿最后一个就可以
 */
  vector<int> rightSideView(TreeNode *root) {
      vector<int> res;
      if(!root)
          return res;
      queue<TreeNode *> record;
      record.push(root);
      while (!record.empty()){
          int size = record.size();
          TreeNode *node;
          while (size--) {
              node = record.front();
              record.pop();
              if (node->left)
                  record.push(node->left);
              if (node->right)
                  record.push(node->right);
          }
          res.push_back(node->val);
      }
      return res;
  }
};

637.二叉树的层平均值

/*637. 二叉树的层平均值
    简单

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10^-5 以内的答案可以被接受。*/

/**
 * 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_637 {
 public:
  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) {}
  };
/*
 * 本题就是102 层序遍历的时候把一层求个总和在取一个均值。
 */
  vector<double> averageOfLevels(TreeNode *root) {
      vector<double> res;
      if (!root)
          return res;
      queue<TreeNode *> record;
      record.push(root);
      while (!record.empty()) {
          int size = record.size();
          double sum = 0;
          for(int i = 0; i < size; ++i) {
              TreeNode *node = record.front();
              sum += (node->val);
              record.pop();
              if (node->left)
                  record.push(node->left);
              if (node->right)
                  record.push(node->right);
          }
          res.push_back(sum / size);
      }
      return res;
  }
};

429.N叉树的层序遍历

/*429. N 叉树的层序遍历
中等
给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。
树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。*/

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution_429 {
 public:
  class Node {
   public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
  };
/*
 * 102  层序遍历类似
 */
  vector<vector<int>> levelOrder(Node* root) {
      vector<vector<int>> res;
      if(!root)
          return res;
      queue<Node*> record;
      record.push(root);
      while (!record.empty()){
          vector<int> temp;
          int size = record.size();
          while (size--){
              Node* node = record.front();
              record.pop();
              temp.push_back(node->val);
              for(auto i : node->children){
                  if(i)
                      record.push(i);
              }
          }
          res.push_back(temp);
      }
      return res;
  }
};

515.在每个树行中找最大值

/*
515. 在每个树行中找最大值
    中等
给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。
*/

class Solution_515 {
 public:
  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) {}
  };



  vector<int> largestValues(TreeNode *root) {
      vector<int> res;
      if (!root)
          return res;
      queue<TreeNode *> record;
      record.push(root);
      while (!record.empty()) {
          int size = record.size();
          int max_num = record.front()->val;
          for (int i = 0; i < size; i++) {
              TreeNode *node = record.front();
              if (max_num < node->val)
                  max_num = (node->val);
              record.pop();
              if (node->left)
                  record.push(node->left);
              if (node->right)
                  record.push(node->right);
          }
          res.push_back(max_num);
      }
      return res;
  }
};

116.填充每个节点的下一个右侧节点指针

/*116. 填充每个节点的下一个右侧节点指针
    中等
给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL。*/

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;
    Node* next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node* _left, Node* _right, Node* _next)
        : val(_val), left(_left), right(_right), next(_next) {}
};
*/

class Solution_116 {
 public:
  class Node {
   public:
    int val;
    Node *left;
    Node *right;
    Node *next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node *_left, Node *_right, Node *_next)
        : val(_val), left(_left), right(_right), next(_next) {}
  };

  Node *connect(Node *root) {
      if (!root)
          return root;
      queue<Node *> record;
      record.push(root);
      while (!record.empty()) {
          int size = record.size();
          while (size--) {
              Node *node = record.front();
              record.pop();
              if (size > 0)
                  node->next = record.front();
              if (node->left)
                  record.push(node->left);
              if (node->right)
                  record.push(node->right);
          }
      }
      return root;
  }
};

117.填充每个节点的下一个右侧节点指针II

/*代码
117. 填充每个节点的下一个右侧节点指针 II
中等

    给定一个二叉树：
struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。
初始状态下，所有 next 指针都被设置为 NULL 。*/
class Solution_117 {
 public:
  class Node {
   public:
    int val;
    Node *left;
    Node *right;
    Node *next;

    Node() : val(0), left(NULL), right(NULL), next(NULL) {}

    Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}

    Node(int _val, Node *_left, Node *_right, Node *_next)
        : val(_val), left(_left), right(_right), next(_next) {}
  };

  Node *connect(Node *root) {
      if (!root)
          return root;
      queue<Node *> record;
      record.push(root);
      while (!record.empty()) {
          int size = record.size();
          while (size--) {
              Node *node = record.front();
              record.pop();
              if (size > 0)
                  node->next = record.front();
              if (node->left)
                  record.push(node->left);
              if (node->right)
                  record.push(node->right);
          }
      }
      return root;
  }
};

104.二叉树的最大深度

/*104. 二叉树的最大深度
    简单
给定一个二叉树 root ，返回其最大深度。
二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。*/
class Solution_104 {
 public:
  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) {}
  };

  int maxDepth(TreeNode* root) {
      int res = 0;
      if(!root)
          return res;
      queue<TreeNode*> record;
      record.push(root);
      while (!record.empty()){
          res += 1;
          int size = record.size();
          while (size--) {
              TreeNode *node = record.front();
              record.pop();
              if (node->left)
                  record.push(node->left);
              if (node->right)
                  record.push(node->right);
          }
      }
      return res;
  }
};

111.二叉树的最小深度

/*111. 二叉树的最小深度
    简单
给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。*/
class Solution_111 {
 public:
  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) {}
  };

  int minDepth(TreeNode* root) {
      int res = 0;
      if(!root)
          return res;
      queue<TreeNode*> record;
      record.push(root);
      while (!record.empty()){
          res += 1;
          int size = record.size();
          while (size--) {
              TreeNode *node = record.front();
              record.pop();
              if (node->left)
                  record.push(node->left);
              if (node->right)
                  record.push(node->right);
              if(!node->left && !node->right)
                  return res;
          }
      }
      return res;
  }
};

● 226.翻转二叉树

/*226. 翻转二叉树
    简单
给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。*/

/**
 * 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_226 {
 public:
  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) {}
  };

  /*
   * 102 层序遍历类似
   * 还有其他方法，广度优先搜索，但是中序不方便，
   * 递归也可以
   */
  TreeNode *invertTree(TreeNode *root) {
      if(!root)
          return root;
      queue<TreeNode *> record;
      record.push(root);
      while (!record.empty()) {
          int size = record.size();
          while (size--) {
              TreeNode *node = record.front();
              record.pop();
              TreeNode *temp = node->left;
              node->left = node->right;
              node->right = temp;
              if(node->left)
                  record.push(node->left);
              if(node->right)
                  record.push(node->right);
          }
      }
      return root;
  }
};

● 101.对称二叉树 2

/*101. 对称二叉树
    简单
给你一个二叉树的根节点 root ， 检查它是否轴对称。*/
class Solution_101 {
 public:
  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) {}
  };
/*
 * 队列存左子树,栈存右子树,这样可以比较值，但是队列跟栈的内部还需要区分左右子树，这个没法区分了
 * 本质上还是遍历节点，只不过需要分左右子树遍历，并且遍历顺序刚好相反
 * 那就可以分左右子树进行递归,分别比较左右子树的内侧节点与外侧节点是否相等
 * 返回参数为是否对称，输入参数为左右节点
 * 单次递归逻辑为左节点的左子树与右节点的右子树是否相等，左节点的右子树与右节点的左子树是否相等
 * 终止条件就是当传入节点一个为空一个不为空时，或者两个都为空时,两个都不为空且值不相等
 * 还可以使用迭代法，通过队列比较，未实现
 */

  bool order(TreeNode *left_node, TreeNode *right_node) {
      if (!left_node && !right_node)
          return true;
      else if (!left_node || !right_node)
          return false;
      else if(left_node->val != right_node->val)
          return false;
      else {//两个都不为空且值相等
          bool outside = order(left_node->left, right_node->right);
          bool inside = order(left_node->right, right_node->left);
          return outside & inside;
      }
  }

  bool isSymmetric(TreeNode *root) {
      if (!root)
          return false;
      bool res = order(root->left, root->right);
      return res;
  }
};