</pre>第一种最常用的就是直接暴力递归的方法:<p></p><p></p><pre name="code" class="cpp">/**
* Definition of TreeNode:
* class TreeNode {
* public:
* int val;
* TreeNode *left, *right;
* TreeNode(int val) {
* this->val = val;
* this->left = this->right = NULL;
* }
* }
*/
class Solution {
public:
/**
* @param root: The root of binary tree.
* @return: Preorder in vector which contains node values.
*/
vector<int> preorderTraversal(TreeNode *root) {
// write your code here
vector<int> result;
if(root){
trav_pre(root, result);
}
return result;
}
private:
void trav_pre(TreeNode *x, vector<int> &ret) {
if (x == nullptr){
return;
}
ret.push_back(x -> val);
trav_pre(x -> left, ret);
trav_pre(x -> right, ret);
}
};
第二种是使用分而治之的方法:
这种方法在现实中比较常用,相当于本身前序遍历,就是为了实现一个接口,这样通过不断调用本接口来解决问题。
class Solution {
public:
/**
* @param root: The root of binary tree.
* @return: Preorder in vector which contains node values.
*/
vector<int> preorderTraversal(TreeNode *root) {
// write your code here
vector<int> result;
if (root == nullptr) {
return result;
}
//devide
vector<int> left = preorderTraversal(root -> left);
vector<int> right = preorderTraversal(root -> right);
//conquer
result.push_back(root -> val);
result.insert(result.end(), left.begin(), left.end());
result.insert(result.end(), right.begin(), right.end());
return result;
}
};
第三种是使用非递归的方法:
这个方法的关键就是引入栈,用栈来代替递归的思想
class Solution {
public:
/**
* @param root: The root of binary tree.
* @return: Preorder in vector which contains node values.
*/
vector<int> preorderTraversal(TreeNode *root) {
// write your code here
vector<int> result;
stack<TreeNode *> sta;
while(1){
travel_pre(root, result, sta);
if(sta.empty()){
break;
}
root = sta.top();
sta.pop();
}
return result;
}
private:
void travel_pre(TreeNode *x, vector<int> &ret, stack<TreeNode *> &st) {
while (x){
ret.push_back(x -> val);
st.push(x -> right);
x = x -> left;
}
return;
}
};
不用递归的另外一种写法:
class Solution {
public:
/**
* @param root: The root of binary tree.
* @return: Preorder in vector which contains node values.
*/
vector<int> preorderTraversal(TreeNode *root) {
// write your code here
vector<int> result;
stack<TreeNode *> sta;
if (root == nullptr){
return result;
}
sta.push(root);
while(!sta.empty()) {
TreeNode * tem = sta.top();
result.push_back(tem -> val);
sta.pop();
if (tem -> right) {//因为是前序遍历,栈是先进后出,因此先放右边再放左边
sta.push(tem -> right);
}
if (tem -> left) {
sta.push(tem -> left);
}
}
return result;
}
};