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;
    }