前序遍历递归：

struct TreeNode {
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode(int x):val(x),left(NULL),right(NULL){}
};

class Solution {
public:
	vector<int> PreOrder(TreeNode* root) {
		vector<int> res;
		Order(root, res);
		return res;
	}
	void Order(TreeNode* root,vector<int>& res) {
		if (root == NULL)return;
		res.push_back(root->val);
		Order(root->left, res);
		Order(root->right, res);
	}
};

int main() {
	TreeNode* A = new TreeNode(1);
	TreeNode* B = new TreeNode(2);
	TreeNode* C = new TreeNode(3);
	A->right = B;
	B->left = C;
	Solution ss;
	vector<int> result = ss.PreOrder(A);
	for (auto& ch: result) {
		cout << ch << " ";
	}
	cout << endl;
	return 0;
}

前序遍历非递归：

struct TreeNode {
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode(int x) :val(x), left(NULL), right(NULL) {}
};

class Solution {
public:
	vector<int> PreOrder(TreeNode* root) {
		stack<TreeNode*> st;
		vector<int> res;
		st.push(root);
		while (!st.empty()) {
			TreeNode* node = st.top();
			st.pop();
			res.push_back(node->val);
			if (node->right)st.push(node->right);
			if (node->left)st.push(node->left);
		}
		return res;
	}
};

int main() {
	TreeNode* A = new TreeNode(1);
	TreeNode* B = new TreeNode(2);
	TreeNode* C = new TreeNode(3);
	A->right = B;
	B->left = C;
	Solution ss;
	vector<int> result = ss.PreOrder(A);
	for (auto& ch : result) {
		cout << ch << " ";
	}
	cout << endl;
	return 0;
}

后序递归

struct TreeNode {
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode(int x) :val(x), left(NULL), right(NULL) {}
};

class Solution {
public:
	vector<int> AfterOrder(TreeNode* root) {
		vector<int> res;
		dfs(root, res);
		return res;
	}
	void dfs(TreeNode* root,vector<int>& res) {
		if (root == NULL)return;
		dfs(root->left, res);
		dfs(root->right, res);
		res.push_back(root->val);
	}
};

int main() {
	TreeNode* A = new TreeNode(1);
	TreeNode* B = new TreeNode(2);
	TreeNode* C = new TreeNode(3);
	A->right = B;
	B->left = C;
	Solution ss;
	vector<int> result = ss.AfterOrder(A);
	for (auto& ch : result) {
		cout << ch << " ";
	}
	cout << endl;
	return 0;
}

后序非递归

struct TreeNode {
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode(int x):val(x),left(NULL),right(NULL){}
};

class Solution {
public:
	vector<int> AfterOrder(TreeNode* root) {
		stack<TreeNode*> st;
		vector<int> res;
		st.push(root);
		while (!st.empty()) {
			TreeNode* node = st.top();
			st.pop();
			res.push_back(node->val);
			if (node->left)st.push(node->left);
			if (node->right)st.push(node->right);
		}
		reverse(res.begin(), res.end());
		return res;
	}
};

int main() {
	TreeNode* A = new TreeNode(1);
	TreeNode* B = new TreeNode(2);
	TreeNode* C = new TreeNode(3);
	A->right = B;
	B->left = C;
	Solution ss;
	vector<int> result = ss.AfterOrder(A);
	for (auto& ch : result) {
		cout << ch << " ";
	}
	cout << endl;
	return 0;
}

中序递归

struct TreeNode {
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode(int x) :val(x), left(NULL), right(NULL) {}
};

class Solution {
public:
	vector<int> Order(TreeNode* root) {
		
		vector<int>res;
		dfs(root, res);
		return res;
	}
	void dfs(TreeNode* root,vector<int>& res) {
		if (root == NULL)return;
		dfs(root->left, res);
		res.push_back(root->val);
		dfs(root->right, res);
	}
};

int main() {
	TreeNode* A = new TreeNode(1);
	TreeNode* B = new TreeNode(2);
	TreeNode* C = new TreeNode(3);
	A->right = B;
	B->left = C;
	Solution ss;
	vector<int> result = ss.Order(A);
	for (auto& ch : result) {
		cout << ch << " ";
	}
	cout << endl;
	return 0;
}