二叉树的先、中、后、层次 遍历的模板

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

先序遍历（NLR）

递归版本

void preOrder(TreeNode* root){
    if (!root) return;
    // process root
    preOrder(root->left); // left child
    preOrder(root->right); // right child
}

非递归版

	vector<int> preorderTraversal(TreeNode* root) {
		std::queue<TreeNode*> qu;
		vector<int> result;
		if (root == NULL) return result;
		qu.push(root);
		while (!qu.empty()) {
			TreeNode* node = qu.front();                       // 中
			qu.pop();

			// process root node
			result.push_back(node->val);

			if (node->left) qu.push(node->left);             // 左（空节点不入栈）
			if (node->right) qu.push(node->right);           // 右（空节点不入栈）
		}
		return result;
	}

中序遍历（LNR）

void inorder(TreeNode* root){
    if (!root) return;
    inorder(root->left);// left child
    //TreeList.push_back(root);// process root
    inorder(root->right); // right child
}

非递归版

vector<int> inorderTraversal(TreeNode* root) {
		vector<int> result;
		std::stack<TreeNode*> st;
		TreeNode* cur = root;
		while (cur != NULL || !st.empty()) {
			if (cur != NULL) { // 指针来访问节点，访问到最底层
				st.push(cur); // 将访问的节点放进栈
				cur = cur->left;                // 左
			}
			else {
				cur = st.top(); // 从栈里弹出的数据，就是要处理的数据（放进result数组里的数据）
				st.pop();
				result.push_back(cur->val);     // 中
				cur = cur->right;               // 右
			}
		}
		return result;
	}

后序遍历（LRN）

void postOrder(TreeNode *root) {
    if (!root) return;
    postOrder(root->left); // left child
    postOrder(root->right); // right child
    // process root
} 

非递归版

vector<int> postorderTraversal(TreeNode* root) {
	std::queue<TreeNode*> qu;
	vector<int> result;
	if (root == NULL) return result;
	qu.push(root);
	while (!qu.empty()) {
		TreeNode* node = qu.front();                       // 中
		qu.pop();

		// process root node
		result.push_back(node->val);

		if (node->right) qu.push(node->right);           // 右（空节点不入栈）
		if (node->left) qu.push(node->left);             // 左（空节点不入栈）

	}
	reverse(result.begin(), result.end()); // 将结果反转之后就是左右中的顺序了
	return result;
}

层次遍历

void bfs(TreeNode *root) {
    queue<TreeNode*> pq;
    int deep = 0;//深度
    pq.push(root);
    while (!pq.empty()) {
        int sz = pq.size();
        while (sz--) {
            TreeNode *node = pq.front(); pq.pop();
            // process node， ours tasks
            // push value to queue
            if (node->left) pq.push(node->left);
            if (node->right) pq.push(node->right);
        } // end inner while
        ++deep;
    } // end outer while
}
// 例如
vector<int> PrintFromTopToBottom(TreeNode* root) {
    vector<int> vRet;
    int deep = 0; //深度
    if(nullptr == root) return vRet;
    queue<TreeNode*> q;
    q.push(root);
    while(!q.empty()){
        int sz = q.size();
        while(sz--){
            TreeNode* node = q.front(); q.pop();
            vRet.push_back(node->val);
            if(node->left) q.push(node->left);
            if(node->right) q.push(node->right);
        }
        ++deep;
    }
    return vRet;
}