leetcode刷题笔录-5

数组转平衡二叉查找树

• 给定一个已排序的数组，将其转化为一棵平衡二叉查找树。平衡的概念是：任一节点的左子树和右子树的深度之差不大于1。
• 思路：数组是可以通过下标来访问的，所以去中点作为根节点，然后递归地生成左右子树。
• 实现：
  

  /**
  
   * Definition for binary tree
  
   * struct TreeNode {
  
   *     int val;
  
   *     TreeNode *left;
  
   *     TreeNode *right;
  
   *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  
   * };
  
   */
  
  class Solution {
  
  public:
  
      TreeNode *sortedArrayToBST(vector<int> &num) {
  
          return _sortArrayToBST(num, 0, num.size()-1);
  
      }
  
  private:
  
      TreeNode *_sortArrayToBST(vector<int> &num, int i, int j){
  
          if(i>j){
  
              return NULL;
  
          }
  
          else{
  
              int r = (i+j+1)/2;
  
              TreeNode *root = new TreeNode(num[r]);
  
              root->left = _sortArrayToBST(num, i, r-1);
  
              root->right = _sortArrayToBST(num, r+1, j);
  
              return root;
  
          }       
  
      }
  
  }; 

 链表转平衡二叉树

• 给定一个已排序的链表，将其转化为一棵平衡二叉查找树。
• 将链表转化为数组，再按照上一个方法实现，并为造成时间复杂度的增加。
• 实现：
  

  /**
  
   * Definition for singly-linked list.
  
   * struct ListNode {
  
   *     int val;
  
   *     ListNode *next;
  
   *     ListNode(int x) : val(x), next(NULL) {}
  
   * };
  
   */
  
  /**
  
   * Definition for binary tree
  
   * struct TreeNode {
  
   *     int val;
  
   *     TreeNode *left;
  
   *     TreeNode *right;
  
   *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  
   * };
  
   */
  
  class Solution {
  
  public:
  
      TreeNode *sortedListToBST(ListNode *head) {
  
          vector<int> num;
  
          while(head != NULL){
  
              num.push_back(head->val);
  
              head=head->next;
  
          }
  
          return _sortArrayToBST(num, 0, num.size()-1);
  
          
  
      }
  
  private:
  
      TreeNode *_sortArrayToBST(vector<int> &num, int i, int j){
  
          if(i>j){
  
              return NULL;
  
          }
  
          else{
  
              int r = (i+j+1)/2;
  
              TreeNode *root = new TreeNode(num[r]);
  
              root->left = _sortArrayToBST(num, i, r-1);
  
              root->right = _sortArrayToBST(num, r+1, j);
  
              return root;
  
          }
  
      }
  
  }; 

二叉树的层序遍历

• 给定一棵二叉树，按照节点深度的顺序输出所有节点的值，同一层的节点按照从左到右的顺序输出。比如，给出二叉树：
  

      3
  
     / \
  
    9  20
  
      /  \
  
     15   7

  则应当输出

  [
  
    [3],
  
    [9,20],
  
    [15,7]
  
  ]

• 思路：在函数外维护一个值，记录当前节点的深度，输出时就依据这个值向二维数组中插入节点的值。
• 实现：
  

  class Solution {
  
  public:
  
      vector<vector<int>> levelOrder(TreeNode *root) {
  
          vector<vector<int>> rslt;
  
          _levelOrder(root, 0, rslt);
  
          return rslt;
  
      }
  
      
  
      void _levelOrder(TreeNode *root, int i, vector<vector<int>>& rslt){
  
          if(root == NULL){
  
              return;
  
          }
  
          else{
  
              if(i>(int)(rslt.size())-1){
  
                  vector<int> tmp;
  
                  tmp.push_back(root->val);
  
                  rslt.push_back(tmp);
  
              }
  
              else{
  
                  rslt[i].push_back(root->val);
  
              }
  
              _levelOrder(root->left, i+1, rslt);
  
              _levelOrder(root->right, i+1, rslt);            
  
          }
  
      }
  
  }; 

二叉树的逆层序遍历

• 给定一棵二叉树，按照逆向层序遍历所有节点值。
• 思路：同上，获得结果后逆序即可。
  

  class Solution {
  
  public:
  
      vector<vector<int>> levelOrderBottom(TreeNode *root) {
  
          vector<vector<int>> rslt;
  
          _levelOrder(root, 0, rslt);
  
          vector<vector<int>> rsltReverse;
  
          for(int i=rslt.size()-1; i>=0; i--){
  
              rsltReverse.push_back(rslt[i]);
  
          }
  
          return rsltReverse;
  
      }
  
      
  
      void _levelOrder(TreeNode *root, int i, vector<vector<int>>& rslt){
  
          if(root == NULL){
  
              return;
  
          }
  
          else{
  
              if(i>(int)(rslt.size())-1){
  
                  vector<int> tmp;
  
                  tmp.push_back(root->val);
  
                  rslt.push_back(tmp);
  
              }
  
              else{
  
                  rslt[i].push_back(root->val);
  
              }
  
              _levelOrder(root->left, i+1, rslt);
  
              _levelOrder(root->right, i+1, rslt);            
  
          }
  
      }
  
  }; 

同一棵树

• 给定两棵二叉树，判断其是否完全相同。
• 思路：如果两棵二叉树的节点值相同，而且左右子树都相同，那么二叉树就完全相同。注意考虑二叉树为空的情况。
  

  /**
  
   * Definition for binary tree
  
   * struct TreeNode {
  
   *     int val;
  
   *     TreeNode *left;
  
   *     TreeNode *right;
  
   *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  
   * };
  
   */
  
  class Solution {
  
  public:
  
      bool isSameTree(TreeNode *p, TreeNode *q) {
  
          if(p==NULL && q==NULL){
  
              return true;
  
          }
  
          else if(p==NULL || q==NULL){
  
              return false;
  
          }
  
          else if(p->val == q->val){
  
              return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
  
          }
  
          else{
  
              return false;
  
          }
  
      }
  
  }; 

对称二叉树

• 给定一棵二叉树，判断其是否是对称的。
• 思路：这里应当把“一棵对称的二叉树”问题转化为“两棵对称的二叉树”问题。如果两棵二叉树节点值相同，而且树A的左子树与树B的右子树对称，树A的右子树与树B的左子树对称，那么这两棵二叉树就是对称的。如果某一棵二叉树的左右子树对称，那么它就是“一棵对称的二叉树”。
• 实现：
  

  /**
  
   * Definition for binary tree
  
   * struct TreeNode {
  
   *     int val;
  
   *     TreeNode *left;
  
   *     TreeNode *right;
  
   *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  
   * };
  
   */
  
  class Solution {
  
  public:
  
      bool isSymmetric(TreeNode *root) {
  
          if(root==NULL){
  
              return true;
  
          }
  
          else{
  
              return _isSymmetric(root->left, root->right);
  
          }
  
      }
  
      
  
      bool _isSymmetric(TreeNode *root1, TreeNode *root2){
  
          if(root1==NULL && root2==NULL){
  
              return true;
  
          }
  
          else if(root1==NULL || root2==NULL){
  
              return false;
  
          }
  
          else if(root1->val == root2->val){
  
              return _isSymmetric(root1->left, root2->right) && _isSymmetric(root1->right, root2->left);
  
          }
  
          else{
  
              return false;
  
          }
  
          
  
      }
  
  };