一、层序遍历
暂时只学层序遍历的迭代法,后面的几个题目都建立在层序遍历的模板上写。
层序遍历要每一层分开装到二维数组中。
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
queue<TreeNode*> que;
if (root != NULL) que.push(root);
vector<vector<int>> result;
while (!que.empty()) {
int size = que.size();
vector<int> vec;
// 这里一定要使用固定大小size,不要使用que.size(),因为que.size是不断变化的
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;
}
};
429. N 叉树的层序遍历
class Solution {
public:
vector<vector<int>> levelOrder(Node* root) {
queue<Node*> que;
if (root != NULL) que.push(root);
vector<vector<int>> result;
while (!que.empty()) {
int size = que.size();
vector<int> vec;
// 这里一定要使用固定大小size,不要使用que.size(),因为que.size是不断变化的
for (int i = 0; i < size; i++) {
Node* node = que.front();
que.pop();
vec.push_back(node->val);
for(int j=0; j<node->children.size(); j++){
que.push(node->children[j]);
}
}
result.push_back(vec);
}
return result;
}
};
199. 二叉树的右视图
class Solution {
public:
vector<int> rightSideView(TreeNode* root) {
queue<TreeNode*> que;
if(root == nullptr){
return {};
}
que.push(root);
vector<int> result;
while(que.empty() != true){//队列非空时
int size = que.size();
TreeNode* cur = que.front();
for (int i = 0; i < size; i++) {
TreeNode* node = que.front();
que.pop();
if(i == size-1) result.push_back(node->val);
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
}
return result;
}
};
515. 在每个树行中找最大值
class Solution {
public:
vector<int> largestValues(TreeNode* root) {
queue<TreeNode*> que;
if (root != NULL) que.push(root);
vector<int> result;
while (!que.empty()) {
int size = que.size();
int tmp = que.front()->val;
// 这里一定要使用固定大小size,不要使用que.size(),因为que.size是不断变化的
for (int i = 0; i < size; i++) {
TreeNode* node = que.front();
que.pop();
tmp = tmp > node->val ? tmp : node->val;
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
result.push_back(tmp);
}
return result;
}
};
116. 填充每个节点的下一个右侧节点指针
这题过得莫名其妙的,马后炮的想,只有两种情况要加next,一是同一父节点下的左右节点,二是相邻父节点的右节点和左节点,这一切的前提,都是题目给了这是一个完美二叉树。
class Solution {
public:
Node* connect(Node* root) {
queue<Node*> que;
if (root != NULL) {
que.push(root);
}
while (!que.empty()) {
int size = que.size();
Node* front = que.front();
// 这里一定要使用固定大小size,不要使用que.size(),因为que.size是不断变化的
for (int i = 0; i < size; i++) {
Node* node = que.front();
que.pop();
if(node->right && node->next && node->next->left) node->right->next = node->next->left;
if( node->left && node->right) node->left->next = node->right;
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
}
return root;
}
};
117. 填充每个节点的下一个右侧节点指针 II
这个代码可以解决上一题,其实层序遍历的时候,能遍历到每一层的所有节点,只需要用一个指针记录pre即可
class Solution {
public:
Node* connect(Node* root) {
queue<Node*> que;
if (root != NULL) {
que.push(root);
}
while (!que.empty()) {
int size = que.size();
Node* node;
Node*pre= NULL;
// 这里一定要使用固定大小size,不要使用que.size(),因为que.size是不断变化的
for (int i = 0; i < size; i++) { //同一层记录pre指针,当pre非空时,pre->next指向当前节点即可
node = que.front();
que.pop();
if(pre) pre->next=node;
pre = node;
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
}
return root;
}
};
104. 二叉树的最大深度
class Solution {
public:
int maxDepth(TreeNode* root) {
int i=0;
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);
}
i++;
}
return i;
}
};
111. 二叉树的最小深度
class Solution {
public:
int minDepth(TreeNode* root) {
queue<TreeNode*> que;
if (root != NULL) que.push(root);
int cnt = 0;
while (!que.empty()) {
int size = que.size();
TreeNode* node;
cnt++;
// 这里一定要使用固定大小size,不要使用que.size(),因为que.size是不断变化的
for (int i = 0; i < size; i++) {
node = que.front();
que.pop();
if(!node->left && !node->right) break;
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
if(!node->left && !node->right) break;
}
return cnt;
}
};
二、226. 翻转二叉树
其实就是遍历所有节点,翻转左右子树。前序中序后序层序遍历都是可以的,但是中序遍历的递归算法不可以。
层序遍历(迭代)
class Solution {
public:
TreeNode* invertTree(TreeNode* root) {
if(!root){
return nullptr;
}//其实是多余的
queue<TreeNode*> que;
if (root != NULL) que.push(root);
while (!que.empty()) {
int size = que.size();
TreeNode* node;
// 这里一定要使用固定大小size,不要使用que.size(),因为que.size是不断变化的
for (int i = 0; i < size; i++) {
node = que.front();
que.pop();
swap(node->right,node->left);
if (node->left) que.push(node->left);
if (node->right) que.push(node->right);
}
}
return root;
}
};
先序遍历(递归)
后序直接把swap放后面就行。
class Solution {
public:
void preOrder(TreeNode *cur){
if(!cur){
return;
}
swap(cur->left,cur->right);//先序
preOrder(cur->left);
preOrder(cur->right);
//swap(cur->left,cur->right);//后序
}
TreeNode* invertTree(TreeNode* root) {
preOrder(root);
return root;
}
};
三、101. 对称二叉树
这题要想到是判断左右两棵子树相同即可得出对称
class Solution {
public:
bool compare(TreeNode* left,TreeNode* right){
if(!left && !right){
return true;
}
if((!left && right) || (left && !right)){
return false;
}
if(left->val != right->val){
return false;
}
bool outside = compare(left->left,right->right);//外侧
bool inside = compare(left->right,right->left); //内侧
bool result = outside && inside;
return result;
}
bool isSymmetric(TreeNode* root) {
return compare(root->left,root->right);
}
};
四、总结
对于递归的使用还是非常不娴熟,要多多练习。
(4小时)