二叉树遍历

前序遍历（根->左->右）

递归写法

void preorder(TreeNode *root, vector<int>& path) {
    if(root != nullptr) {
        path.push_back(root->val);
        preorder(root->left, path);
        preorder(root->right, path);
    }
}

非递归写法

// 写法一
void preorder(TreeNode* root, vector<int>& path) {
	if (root == nullptr) return;
	stack<TreeNode*> stk;
	stk.push(root);
	while(!stk.empty()) {
		TreeNode* node = stk.pop();
		path.push_back(node->val);
		if (node->right) {
			stk.push(node->right);
		}
		if (node->left) {
			stk.push(node->left)
		}
	}
}

// 写法二
void preorder(TreeNode* root, vector<int>& path) {
	if (root == nullptr) return;
	stack<TreeNode*> stk;
	TreeNode* p = root;
	while ( p != nullptr || !stk.empty()) {
		if (p != nullptr) {
			path.push_back(p->val);
			stk.push(p);
			p = p->left;
		} else {
			p = stk.pop();
			p = p->right;
		}
	}
}

中序遍历（左->根->右）

递归写法

void inorder(TreeNode* root, vector<int>& path) {
	if (root == nullptr) return;
	inorder(root->left, path);
	path.push_back(root->val);
	inorder(root->left);
}

非递归写法

void inorder(TreeNode* root, vector<int>& path) {
	if (root == nullptr) return;
	stack<TreeNode*> stk;
	TreeNode* p = root;
	while (p != nullptr || !stk.empty()) {
		if (p != nullptr) {
			stk.push(p);
			p = p->left;
		} else {
			p = stk.pop();
			path.push_back(p->val);
			p = p->right;
		}
	}
}

后序遍历（左->右->根）

递归写法

void post(TreeNode* root, vector<int>& res) {
    if (root == nullptr) return ;
    post(root->left);
    post(root->right);
    res.push_back(root->val);
}

非递归写法

void post_loop(TreeNode* root, vector<int>& res) {
    if (root == nullptr) return;
    stack<TreeNode*> stk1;
    stack<TreeNode*> stk2;
    stk1.push(root);
    while (!stk1.empty()) {
        TreeNode* node = stk1.pop();
        stk2.push(node);
        stk1.push(node->left);
        stk1.push(node->right);
    }
    while(!stk2.empty()) {
        res.push_back(skt2.pop()->val);
    }
}