1.树层次遍历算法,返回树深度
#include <iostream>
#include <queue>
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
int maxDepth(TreeNode* root) {
if (root == nullptr) {
return 0;
}
std::queue<TreeNode*> q;
q.push(root);
int depth = 0;
while (!q.empty()) {
int levelSize = q.size();
depth++;
for (int i = 0; i < levelSize; i++) {
TreeNode* node = q.front();
q.pop();
if (node->left != nullptr) {
q.push(node->left);
}
if (node->right != nullptr) {
q.push(node->right);
}
}
}
return depth;
}
int main() {
TreeNode* root = new TreeNode(1);
root->left = new TreeNode(2);
root->right = new TreeNode(3);
root->left->left = new TreeNode(4);
root->left->right = new TreeNode(5);
root->right->right = new TreeNode(6);
std::cout << "Depth of the tree: " << maxDepth(root) << std::endl;
delete root->left->left;
delete root->left->right;
delete root->right->right;
delete root->left;
delete root->right;
delete root;
return 0;
}
2.树前序遍历(非递归)
#include <iostream>
#include <stack>
#include <vector>
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
std::vector<int> preorderTraversal(TreeNode* root) {
std::vector<int> result;
std::stack<TreeNode*> stk;
TreeNode* current = root;
while (current != nullptr || !stk.empty()) {
if (current != nullptr) {
result.push_back(current->val);
if (current->right != nullptr) {
stk.push(current->right);
}
current = current->left;
} else {
current = stk.top();
stk.pop();
}
}
return result;
}
int main() {
TreeNode* root = new TreeNode(1);
root->left = new TreeNode(2);
root->right = new TreeNode(3);
root->left->left = new TreeNode(4);
root->left->right = new TreeNode(5);
std::vector<int> result = preorderTraversal(root);
std::cout << "Preorder traversal result: ";
for (int num : result) {
std::cout << num << " ";
}
std::cout << std::endl;
delete root->left->left;
delete root->left->right;
delete root->left;
delete root->right;
delete root;
return 0;
}
3.树中序遍历(非递归)
#include <iostream>
#include <stack>
#include <vector>
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
std::vector<int> inorderTraversal(TreeNode* root) {
std::vector<int> result;
std::stack<TreeNode*> stk;
TreeNode* current = root;
while (current != nullptr || !stk.empty()) {
if (current != nullptr) {
stk.push(current);
current = current->left;
} else {
current = stk.top();
stk.pop();
result.push_back(current->val);
current = current->right;
}
}
return result;
}
int main() {
TreeNode* root = new TreeNode(1);
root->left = new TreeNode(2);
root->right = new TreeNode(3);
root->left->left = new TreeNode(4);
root->left->right = new TreeNode(5);
std::vector<int> result = inorderTraversal(root);
std::cout << "Inorder traversal result: ";
for (int num : result) {
std::cout << num << " ";
}
std::cout << std::endl;
delete root->left->left;
delete root->left->right;
delete root->left;
delete root->right;
delete root;
return 0;
}
4.树后序遍历(非递归)
#include <iostream>
#include <stack>
#include <vector>
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};
std::vector<int> postorderTraversal(TreeNode* root) {
std::vector<int> result;
std::stack<TreeNode*> stk;
TreeNode* current = root;
TreeNode* lastVisited = nullptr;
while (current != nullptr || !stk.empty()) {
if (current != nullptr) {
stk.push(current);
current = current->left;
} else {
TreeNode* topNode = stk.top();
if (topNode->right == nullptr || topNode->right == lastVisited) {
result.push_back(topNode->val);
lastVisited = topNode;
stk.pop();
} else {
current = topNode->right;
}
}
}
return result;
}
int main() {
TreeNode* root = new TreeNode(1);
root->left = new TreeNode(2);
root->right = new TreeNode(3);
root->left->left = new TreeNode(4);
root->left->right = new TreeNode(5);
std::vector<int> result = postorderTraversal(root);
std::cout << "Postorder traversal result: ";
for (int num : result) {
std::cout << num << " ";
}
std::cout << std::endl;
delete root->left->left;
delete root->left->right;
delete root->left;
delete root->right;
delete root;
return 0;
}