方法:递归
class Solution {
private:
void solve(TreeNode* cur, vector<int>& vec) {
if (cur == NULL) return ;
vec.push_back(cur->val);
solve(cur->left, vec);
solve(cur->right, vec);
}
public:
vector<int> preorderTraversal(TreeNode* root) {
vector<int> vec;
solve(root, vec);
return vec;
}
};
$时间复杂度O(n),空间复杂度O(n)
方法:迭代
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector<int> preorderTraversal(TreeNode* root) {
stack<TreeNode*> st;
vector<int> res;
if (root != NULL) st.push(root);
while (!st.empty()) {
TreeNode* nod = st.top();
if (nod != NULL) {
st.pop();
if (nod->right) st.push(nod->right);
if (nod->left) st.push(nod->left);
st.push(nod);
st.push(NULL);
} else {
st.pop();
nod = st.top();
st.pop();
res.push_back(nod->val);
}
}
return res;
}
};
$时间复杂度O(n),空间复杂度O(n)
方法:递归
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
vector<int>ret;
void dfs(TreeNode* root){
if(root){
dfs(root->left);
dfs(root->right);
ret.push_back(root->val);
}
}
public:
vector<int> postorderTraversal(TreeNode* root) {
ret.clear();
dfs(root);
return ret;
}
};
$时间复杂度O(n),空间复杂度O(n)
方法:迭代
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector<int> postorderTraversal(TreeNode* root) {
stack<TreeNode*> st;
vector<int> res;
if (root != NULL) st.push(root);
while (!st.empty()) {
TreeNode* nod = st.top();
if (nod != NULL) {
st.pop();
st.push(nod);
st.push(NULL);
if (nod->right) st.push(nod->right);
if (nod->left) st.push(nod->left);
} else {
st.pop();
nod = st.top();
st.pop();
res.push_back(nod->val);
}
}
return res;
}
};
$时间复杂度O(n),空间复杂度O(n)
class Solution {
private:
void solve(TreeNode* cur, vector<int>& vec) {
if (cur == nullptr) return ;
solve(cur->left, vec);
vec.push_back(cur->val);
solve(cur->right, vec);
}
public:
vector<int> inorderTraversal(TreeNode* root) {
vector<int> vec;
solve(root, vec);
return vec;
}
};
$时间复杂度O(n),空间复杂度O(n)
方法:迭代
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root) {
stack<TreeNode*> st;
vector<int> res;
if (root != NULL) st.push(root);
while (!st.empty()) {
TreeNode* nod = st.top();
if (nod != NULL) {
st.pop();
if (nod->right) st.push(nod->right);
st.push(nod);
st.push(NULL);
if (nod->left) st.push(nod->left);
} else {
st.pop();
nod = st.top();
st.pop();
res.push_back(nod->val);
}
}
return res;
}
};
$时间复杂度O(n),空间复杂度O(n)