代码随想录算法训练营day15|LeetCode102二叉树的层序遍历、LeetCode226翻转二叉树、LeetCode101对称二叉树(补卡)

二叉树part02
LeetCode102二叉树的层序遍历

#include<iostream>
using namespace std;
#include<vector>
#include<queue>
#include<stack>
stack<char> s;
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) :val(x), left(NULL), right(NULL) {};
};
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;
}
//begin指向当前节点
TreeNode* build(string input, int begin, int end) {
    //    1(2(3,4(,5)),6(7,))
        //2(3,4(,5)),6(7,)
        //3,4(,5)    7,
        //4(,5)
    TreeNode* head = NULL;
    if (begin <= end) {
        head = new TreeNode(input[begin] - '0');

        //如果当前节点后有 ( 表示可以继续划分子树，否则就是叶子节点
        if (input[begin + 1] == '(') {
            int cur = begin + 2;

            //使用栈进行括号匹配，找到作为分隔符的那个 ,
            while (!s.empty() || input[cur] != ',') {
                if (input[cur] == '(') {
                    s.push('(');
                }
                else if (input[cur] == ')') {
                    s.pop();
                }
                cur++;
            }
            head->left = build(input, begin + 2, cur - 1);
            head->right = build(input, cur + 1, end - 1);
        }
    }
    return head;
}


int main() {
	string input;
	cin >> input;
	TreeNode* head = build(input, 0, input.size() - 1);
    vector<vector<int>> result = levelOrder(head);
    cout << "结果如下：" << endl;
    for (int i = 0; i < result.size(); i++) {
        for (int j = 0; j < result[i].size(); j++) {
            cout << result[i][j] << " ";
        }
        cout << endl;
    }
	return 0;
}

LeetCode226翻转二叉树

#include<iostream>
using namespace std;
#include<queue>
#include<stack>
stack<char> s;
struct TreeNode {
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode(int x) :val(x), left(NULL), right(NULL) {};
};
TreeNode* invertTree(TreeNode* root) {
	if (root == NULL) return root;
	swap(root->left, root->right);  // 中
	invertTree(root->left);         // 左
	invertTree(root->right);        // 右
	return root;
}
//begin指向当前节点
TreeNode* build(string input, int begin, int end) {	
	TreeNode* head = NULL;
	if (begin <= end) {
		head = new TreeNode(input[begin]-'0');
		if (input[begin + 1] == '(') {
			int cur = begin + 2;
			while (!s.empty() || input[cur] != ',') {
				if (input[cur] == '(') {
					s.push('(');
				}
				else if (input[cur] == ')') {
					s.pop();
				}
				cur++;
			}
			head->left = build(input, begin + 2, cur - 1);
			head->right = build(input,cur+1,end -1);
		}
	}
	return head;
}
void treePrint(TreeNode* root) {
	if (!root) return;
	queue<TreeNode*> que;
	que.push(root);
	while (!que.empty()) {
		int size = que.size();
		for (int i = 0; i < size; i++) {
			TreeNode* node = que.front();
			que.pop();
			if (!node) cout << "NULL ";
			else {
				cout << node->val << " ";
				que.push(node->left);
				que.push(node->right);
			}
		}
		cout << endl;
	}
}
int main() {
	string input;
	cin >> input;
	TreeNode* head = build(input, 0, input.size() - 1);
	treePrint(head);
	treePrint(invertTree(head));
	return 0;
}

LeetCode101对称二叉树

#include<iostream>
using  namespace std;
#include<queue>
#include<stack>
stack<char> s;
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) :val(x), left(NULL), right(NULL) {};
};
bool compare(TreeNode* left, TreeNode* right) {
    // 首先排除空节点的情况
    if (left == NULL && right != NULL) return false;
    else if (left != NULL && right == NULL) return false;
    else if (left == NULL && right == NULL) return true;
    // 排除了空节点，再排除数值不相同的情况
    else if (left->val != right->val) return false;

    // 此时就是：左右节点都不为空，且数值相同的情况
    // 此时才做递归，做下一层的判断
    bool outside = compare(left->left, right->right);   // 左子树：左、 右子树：右
    bool inside = compare(left->right, right->left);    // 左子树：右、 右子树：左
    bool isSame = outside && inside;                    // 左子树：中、 右子树：中 （逻辑处理）
    return isSame;
}
bool isSymmetric(TreeNode* root) {
    if (root == NULL) return true;
    return compare(root->left, root->right);
}
//begin指向当前节点
TreeNode* build(string input, int begin, int end) {	
	TreeNode* head = NULL;
	if (begin <= end) {
		head = new TreeNode(input[begin]-'0');
		if (input[begin + 1] == '(') {
			int cur = begin + 2;
			while (!s.empty() || input[cur] != ',') {
				if (input[cur] == '(') {
					s.push('(');
				}
				else if (input[cur] == ')') {
					s.pop();
				}
				cur++;
			}
			head->left = build(input, begin + 2, cur - 1);
			head->right = build(input,cur+1,end -1);
		}
	}
	return head;
}
void treePrint(TreeNode* root) {
	if (!root) return;
	queue<TreeNode*> que;
	que.push(root);
	while (!que.empty()) {
		int size = que.size();
		for (int i = 0; i < size; i++) {
			TreeNode* node = que.front();
			que.pop();
			if (!node) cout << "NULL ";
			else {
				cout << node->val << " ";
				que.push(node->left);
				que.push(node->right);
			}
		}
		cout << endl;
	}
}
int main() {
    string input;
	cin >> input;
	TreeNode* head = build(input, 0, input.size() - 1);
	treePrint(head);
	cout<<isSymmetric(head)<<endl;
}