C++：二叉树的前中后序遍历（递归与非递归）以及非递归的层序遍历

递归的形式如果是想在牛客网里编译可能得把这个递归过程作为中间过程，要不然容易报错：递归太多之类的。
递归形式：
前序遍历：

  void preorderTraversal(TreeNode* root) {
     
        if (root == NULL) return ;
        res.push_back(root->val);
        preorderTraversal(root->left);
        preorderTraversal(root->right);
    }

中序遍历：

void inorderTraversal(TreeNode* root) {
     
        if (root == NULL) return ;
        inorderTraversal(root->left);
        res.push_back(root->val);
        inorderTraversal(root->right);
    }

后序遍历：

void postorderTraversal(TreeNode* root) {
     
        if (root == NULL) return ;
        postorderTraversal(root->left);
        postorderTraversal(root->right);
         res.push_back(root->val);
    }

非递归形式：
前序遍历

vector<int> preorderTraversal(TreeNode* root) {
     
        // write code here
  //基于堆栈实现的前序排列
    vector<int> res;
	if (root == NULL)
		return res;
	stack<TreeNode*> stk;
	stk.push(root);
	while (!stk.empty())
	{
     
		TreeNode*node = stk.top();
        stk.pop();
		res.push_back(node->val);
		
        //这是栈先进后出，所以注意这里的顺序
		if (node->right != NULL)
			stk.push(node->right);
        
        if (node->left != NULL)
			stk.push(node->left);
	}
	return res;
    }

中序遍历

 vector<int> inorderTraversal(TreeNode* root) {
     
        // write code here
    //栈实现中序遍历，之前还写过先序遍历
    stack<TreeNode*>cur;
	TreeNode* node = root;
	vector<int>res;

	while (!cur.empty() || node != NULL)
	{
     
		while (node != NULL)
		{
     
			cur.push(node);
			node = node->left;
		}

		node = cur.top();
		cur.pop();
		res.push_back(node->val);
		node = node->right;
	}
	return res;
    }

后序遍历

vector<int> postorderTraversal(TreeNode* root) {
     
        // write code here
    stack<TreeNode*>stk;
	TreeNode*cur=NULL;//避免出现野指针
	vector<int>res;
        if(root==NULL)
            return res;
	stk.push(root);
	while (!stk.empty())
	{
     
		cur = stk.top();
		if (cur->left == NULL && cur->right == NULL)
		{
     
			res.push_back(cur->val);
			stk.pop();
		}
		else
		{
     
			if (cur->right != NULL)
			{
     
				stk.push(cur->right);
				cur->right = NULL;//防止内存超出
			}
			if (cur->left != NULL)
			{
     
				stk.push(cur->left);
				cur->left = NULL;
			}
		}
	}
	return res;
    }

//前序遍历：根、左、右   后序遍历：左、右、根   就是根、右、左，然后reverse
vector<int> postorderTraversal(TreeNode* root)
{
     
	vector<int>res;
	if (root == NULL)
		return res;
	stack<TreeNode*>stk;
	TreeNode*node = NULL;
	stk.push(root);
	while (!stk.empty())
	{
     
		node = stk.top();
		res.push_back(node->val);
		stk.pop();
		if (node->left)
			stk.push(node->left);
		if (node->right)
			stk.push(node->right);
	}
	reverse(res.begin(),res.end());
	return res;
}

层序遍历

vector<vector<int> > levelOrder(TreeNode* root) {
     
   //层序遍历主要以队列为基础：先进先出原则
        // write code here
        vector<vector<int>> res;
	if (root == NULL)
		return res;
	queue<TreeNode*>current;
	vector<int> temp;
	current.push(root);
	while (!current.empty())
	{
     
		temp.clear();
		int len = current.size();
		for (int i = 0; i < len; i++)//按照每行的个数打印
		{
     
			TreeNode* node = current.front();
			temp.push_back(node->val);
			current.pop();
			if (node->left != NULL)
				current.push(node->left);;
			if (node->right != NULL)
				current.push(node->right);
		}
		res.push_back(temp);
	}
	return res;
    }