【刷题day15】二叉树|102. 二叉树的层序遍历、107. 二叉树的层序遍历 II、199. 二叉树的右视图、637. 二叉树的层平均值

102. 二叉树的层序遍历

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();// 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            vector<int> vec;//每一层的列表
            for (int i = 0; i < size; i++) {
                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);
            }
            result.push_back(vec);
        }
        return result;
    }

107. 二叉树的层序遍历 II

vector<vector<int>> levelOrderBottom(TreeNode* root) {
        vector<vector<int>> result;//最后要返回的列表
        queue<TreeNode*> que;
        if (root != NULL) 
            que.push(root);
        while (!que.empty()) {
            int size = que.size();// 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            vector<int> vec;//每一层的列表
            for (int i = 0; i < size; i++) {
                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);
            }
            result.push_back(vec);
        }
        reverse(result.begin(),result.end());
        return result;
    }

199. 二叉树的右视图

vector<int> rightSideView(TreeNode* root) {
        vector<int> result;//最后要返回的列表
        queue<TreeNode*> que;
        if (root != NULL) 
            que.push(root);
        while (!que.empty()) {
            int size = que.size();// 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            vector<int> vec;//每一层的列表
            for (int i = 0; i < size; i++) {
                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);
            }
            int a =vec.back();
            result.push_back(a);
        }
        return result;
    }

637. 二叉树的层平均值

溢出

vector<double> averageOfLevels(TreeNode* root) {
        vector<double> result;//最后要返回的列表
        queue<TreeNode*> que;
        double sums,avg;
        if (root != NULL) 
            que.push(root);
        while (!que.empty()) {
            int size = que.size();// 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            vector<int> vec;//每一层的列表
            for (int i = 0; i < size; i++) {
                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);
            }
            sums = accumulate(vec.begin(), vec.end(), 0);
            avg=sums/vec.size();
            result.push_back(avg);
        }
        return result;
    }

通过

vector<double> averageOfLevels(TreeNode* root) {
        queue <TreeNode*> que;
        vector<double>result;
        if (root != NULL) 
            que.push(root);
        while(!que.empty())
        {
            double sum=0;
            int size=que.size();
            for(int i=0;i<size;i++)
            {
                TreeNode* node=que.front();
                que.pop();
                sum+=node->val;
                if(node->left!=NULL) 
                    que.push(node->left);
                if(node->right!=NULL) 
                    que.push(node->right);
            }
            result.push_back(sum/size);
        }
        return result;
    }

429. N 叉树的层序遍历

vector<vector<int>> levelOrder(Node* root) {
       vector<vector<int>> result;//最后要返回的列表
        queue<Node*> que;//给你定义的节点了 不要继续用TreeNode*了
        if (root != NULL) 
            que.push(root);
        while (!que.empty()) {
            int size = que.size();// 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            vector<int> vec;//每一层的列表
            for (int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                vec.push_back(node->val);
                for (Node* child:node->children) //for-each拿出每一个孩子节点
                    que.push(child);
            }
            result.push_back(vec);
        }
        return result; 
    }

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

vector<int> largestValues(TreeNode* root) {
        vector<int> result;//最后要返回的列表
        queue<TreeNode*> que;
        if (root != NULL) 
            que.push(root);
        while (!que.empty()) {
            int size = que.size();// 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            vector<int> vec;//每一层的列表
            for (int i = 0; i < size; i++) {
                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);
            }
            int maxValue = *max_element(vec.begin(),vec.end());
            result.push_back(maxValue);
        }
        return result;
    }

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

Node* connect(Node* root) {
        queue<Node*> que;
        if (root != NULL) 
            que.push(root);
        while (!que.empty()) {
            int size = que.size();// 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                //关键代码
                if(i<size-1)//不是最后一个节点
                    node->next=que.front();
                if (node->left) 
                    que.push(node->left);
                if (node->right) 
                    que.push(node->right);
            }
        }
        return root;
    }

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

和上题一样

Node* connect(Node* root) {
        queue<Node*> que;
        if (root != NULL) 
            que.push(root);
        while (!que.empty()) {
            int size = que.size();// 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                //关键代码
                if(i<size-1)//不是最后一个节点
                    node->next=que.front();
                if (node->left) 
                    que.push(node->left);
                if (node->right) 
                    que.push(node->right);
            }
        }
        return root;
    }

104. 二叉树的最大深度

int maxDepth(TreeNode* root) {
        int len=0;
        queue<TreeNode*> que;
        if (root != NULL) 
            que.push(root);
        while (!que.empty()) {
            int size = que.size();// 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            len++;
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) 
                    que.push(node->left);
                if (node->right) 
                    que.push(node->right);
            }
        }
        return len;
    }

111. 二叉树的最小深度

int minDepth(TreeNode* root) {
        int len=0;
        int minlen=INT_MAX;
        queue<TreeNode*> que;
        if (root == NULL) 
            return 0;
        que.push(root);
        while (!que.empty()) {
            int size = que.size();// 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            len++;
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) 
                    que.push(node->left);
                if (node->right) 
                    que.push(node->right);
                if(!node->left && !node->right)//是叶子节点
                    minlen=min(minlen,len);
            }
        }
        return minlen;
    }

226. 翻转二叉树

递归

TreeNode* invertTree(TreeNode* root) {
        if (root == NULL) 
            return root;
        swap(root->left, root->right);  // 根
        invertTree(root->left);         // 左
        invertTree(root->right);        // 右
        return root;
    }

迭代

TreeNode* invertTree(TreeNode* root) {
        stack<TreeNode*>st;
        if(root==nullptr){
            return{};
        }
        TreeNode *cur=root;//指针因为你的栈里是树节点类型的元素，所以指向栈的指针也要是树节点类性的指针
        while(!st.empty()||cur!=nullptr){
            while(cur!=nullptr){
                //根
                swap(cur->right,cur->left);
                st.push(cur);
                //左
                cur=cur->left;
            }
            cur=st.top();
            st.pop();
            //右
            cur=cur->right;
        }
        return root;
    }

层序

TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) 
            que.push(root);
        while (!que.empty()) {
            int size = que.size();// 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                if (node->left) 
                    que.push(node->left);
                if (node->right) 
                    que.push(node->right);
                swap(node->left,node->right);
            }
        }
        return root;
    }

101. 对称二叉树

本题遍历只能是“后序遍历”，因为我们要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等。

递归

 bool isSymmetric(TreeNode* root) {
        return check(root, root);
    }
    bool check(TreeNode *p, TreeNode *q) {
        if (!p && !q) 
            return true;
        if (!p || !q) 
            return false;
        return p->val == q->val && check(p->left, q->right) && check(p->right, q->left);
        //(1)根节点具有相同的值，(2)p的左子树与q的右子树对称，(3)p的右子树与q的左子树对称
    }

100. 相同的树

bool isSameTree(TreeNode* p, TreeNode* q) {
        if (!p && !q) //两树均空
            return true;
        if (!p || !q) //一个树有，一个树空
            return false;
        return p->val == q->val && isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
    }

572. 另一棵树的子树

bool isSubtree(TreeNode* root, TreeNode* subRoot) {
        if (!root) 
            return false;
        return isSameTree(root, subRoot)||isSubtree(root->left,subRoot)||isSubtree(root->right,subRoot);
    }
    bool isSameTree(TreeNode* p, TreeNode* q) {
        if (!p && !q) //两树均空
            return true;
        if (!p || !q) //一个树有，一个树空
            return false;
        return p->val == q->val && isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
    }