ACM基础（四）：树的遍历

---

一、三种遍历

规则

• 中序遍历inOrderTraversal：左子树——>根节点——>右子树。

• 前序遍历preOrderTraversal：根节点——>左子树——>右子树。

• 后序遍历postOrderTraversal：左子树——>右子树——>根节点 。

记法（遍历规则）：

• 都是左子树在右子树前

• 哪个序遍历，根节点就在哪个位置：中序（，根，），前序（根，，），后序（，，根）。

递归理解

这些遍历都是递归的形式推导出来。比如：

• 中序遍历的递归，前两层(B)A(C)，前三层(DBE)A(FCG)，前四层((DH)BE)A(FCG)

• 前序遍历的递归，前两层(A)B(C)，前三层A(BDE)(CFG)，前四层A(B(DH)E)(CFG)

代码

• 都是递归的左子树在递归的右子树前。
• 哪个序遍历，输出语句就在哪个位置：中序（，根，），前序（根，，），后序（，，根）。

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

// 中序遍历：递归（左根右）
void inOrderTraversal(TreeNode* root, vector<int>& res) {
    if(root)
    {
        inOrderTraversal(root->left);		// 左
        res.push_back(root->val);			// 根
        inOrderTraversal(root->right);		// 右
    }
}

// 中序遍历：栈法（顺序是递归的反转：左根右→右根左）
void inOrderTraversal(TreeNode* root, vector<int>& res) {
	stack<pair<TreeNode*, int> > stk;
	stk.push(make_pair(root, 0));
	
	while(stk.size()) {
	    auto [node, flag] = stk.top();
	    stk.pop();
	    if(node == nullptr) continue;
	    if(flag == 0) {
	        stk.push(make_pair(node->right, 0));		// 右
	        stk.push(make_pair(node, 1));				// 根
	        stk.push(make_pair(node->left, 0));			// 左
	    }
	    else
	    {
	    	res.push_back(node->val);
	    }
	}
}

// 前序遍历：递归（根左右）
void preOrderTraversal(TreeNode* root, vector<int>& res) {
    if(root)
    {
        res.push_back(root->val);			// 根
        preOrderTraversal(root->left);		// 左
        preOrderTraversal(root->right);		// 右
    }
}

// 前序遍历：栈法（顺序是递归的反转：根左右→右左根）
void preOrderTraversal(TreeNode* root, vector<int>& res) {
	stack<pair<TreeNode*, int> > stk;
    stk.push(make_pair(root, 0));
    
    while(stk.size()) {
        auto [node, flag] = stk.top();
        stk.pop();
        if(node == nullptr) continue;
        if(flag == 0) {
            stk.push(make_pair(node->right, 0));		// 右
            stk.push(make_pair(node->left, 0));			// 左
            stk.push(make_pair(node, 1));				// 根
        }
        else
        {
            res.push_back(node->val);
        }
    }
}

// 后序遍历：递归（左右根）
void postOrderTraversal(TreeNode* root, vector<int>& res) {
    if(root)
    {
        postOrderTraversal(root->left);		// 左
        postOrderTraversal(root->right);	// 右
        res.push_back(root->val);			// 根
    }
}

// 后序遍历：栈法（顺序是递归的反转：左右根→根右左）
void postOrderTraversal(TreeNode* root, vector<int>& res) {
	stack<pair<TreeNode*, int> > stk;
    stk.push(make_pair(root, 0));
    
    while(stk.size()) {
        auto [node, flag] = stk.top();
        stk.pop();
        if(node == nullptr) continue;
        if(flag == 0) {
            stk.push(make_pair(node, 1));				// 根
            stk.push(make_pair(node->right, 0));		// 右
            stk.push(make_pair(node->left, 0));			// 左
        }
        else
        {
            res.push_back(node->val);
        }
    }
}

二、层序遍历

直接

void levelOrderTraversal(TreeNode* root, vector<int> &res) {
   if (!root) {
        return;
    }
    queue <TreeNode*> q;
    q.push(root);
    while (q.size()) {
        TreeNode* node = q.front(); 
        q.pop();
        res.push_back(node->val);
        if (node->left)
        {
            q.push(node->left);
        }
        if (node->right)
        {
            q.push(node->right);
        }
    }
}

每层分开

[
  [3],
  [9,20],
  [15,7]
]

void levelOrderTraversal(TreeNode* root, vector<vector<int>>& res) {
    if (!root) {
        return res;
    }
    queue <TreeNode*> q;
    q.push(root);
    while (q.size()) {
        int currentLevelSize = q.size();
        res.push_back(vector<int>());
        for (int i = 0; i < currentLevelSize; i++) {
            TreeNode* node = q.front(); 
            q.pop();
            res.back().push_back(node->val);
            if (node->left)
            {
            	q.push(node->left);
            }
            if (node->right)
            {
            	q.push(node->right);
            }
        }
    }
}