LeetCode 剑指offer刷题记录(Day5 No.14~No.16)

本章节三道题目为搜索与回溯算法

No.14  I. 从上到下打印二叉树

问题描述：从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。

案例：

给定二叉树: [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回：

[3,9,20,15,7]

思路：本题为层序遍历二叉树，通常使用辅助队列帮助实现。

根节点入队->根节点左右节点入队->根节点出队 此时根节点的左节点在队头，让他的左右孩子入队，再让他出队，循环往复直至队列为空

代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> levelOrder(TreeNode* root) {
        queue<TreeNode>q;
        vector<int>v;
        if(root!=NULL){
            q.push(*root); //若树不为空，根节点入队
        }

        while(q.empty() == false){  //循环条件，队列不为空
           if(q.front().left!=NULL){
               q.push(*(q.front().left));
           }    
           if(q.front().right!=NULL){
               q.push(*(q.front().right));
           }
           v.push_back(q.front().val);
           q.pop();
        }
    return v;
    }
};

No.15  II. 从上到下打印二叉树 II

问题描述：从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

案例：

例如:
给定二叉树: [3,9,20,null,null,15,7],

             3
            / \
          9  20
              /  \
           15   7

返回其层次遍历结果：

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

思路：

 难点在于制作辅助队列暂存每一层的元素。当时没想出来，借鉴了java版的代码和讲解后改为了c++版，思路链接：力扣

代码：

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        /* 根据函数返回值定义存储结果的变量 */
        vector<vector<int>> result;
        /* 定义一个队列用于存储节点的数据 */
        queue<TreeNode*> que;
        /* 判空 */
        if(root != NULL) que.push(root);

        /* 开始层序遍历 */
        while(!que.empty()) {
            /* 计算队列的大小也即有多少个孩子 */
            int size = que.size();
            /* 定义一个临时vector 存储每一层 */
            vector<int> vec;
            /* 层序遍历 */
            for(int i = 0; i < size; i++) {
                /* 获取第一个节点数据 */
                TreeNode* node = que.front();
                vec.push_back(node->val);
                que.pop();
                if(node->left != NULL) que.push(node->left);
                if(node->right != NULL) que.push(node->right);
            }
            /* 将一层的数据保存 */
            result.push_back(vec);
        }
        return result;
    }
};

No.16   III. 从上到下打印二叉树 III

问题描述：

请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。

案例：

给定二叉树: [3,9,20,null,null,15,7],

            3
            / \
          9  20
              /  \
           15   7

返回其层次遍历结果：

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

思路：看到z型输出本能的想到用一个辅助栈一个辅助队列，在上一题的基础上加一个count统计本层若是奇数则放入栈，偶数则放入队列。本体空间复杂度较高，有较大优化空间

代码：
 

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
    queue<TreeNode*>q; //暂存树节点
    vector<vector<int>> ans;  //输出队列
    if(root!=NULL){
        q.push(root);
    }
        
    int count=0 ;     //记录层数，偶数层入队列，奇数层入栈    
    while(!q.empty()){
        stack<int>s;   //暂存栈
        queue<int> temp;  //暂存队列
        
        int size=q.size();
        for(int i=size;i>0;i--){  
            if(count%2==0){  //偶数层入队列
                TreeNode* a=q.front();
                q.pop();
                if(a->left!=NULL) q.push(a->left);
                if(a->right!=NULL) q.push(a->right);
                temp.push(a->val);
            }
            if(count%2!=0){   //奇数层入栈
                TreeNode*a=q.front();
                q.pop();
                if(a->left!=NULL) q.push(a->left);
                if(a->right!=NULL) q.push(a->right);
                s.push(a->val);
            }  
        }
        vector<int> v; //暂存数组
        if(count%2==0){
            
            while(!temp.empty()){
              int * c=&(temp.front());
              v.push_back(*c);
              temp.pop();
            }
        }
        else{
            
             while(!s.empty()){
              int * c=&(s.top());
              v.push_back(*c);
              s.pop();
             }
        }
        ans.push_back(v);
        count++;
    }
        return ans;
    }
};