目录

二叉树节点结构：

1.1 前序遍历（Preorder Traversal）：

递归实现（preorderRecursive函数）：首先访问当前节点，然后递归遍历左子树，最后递归遍历右子树。这种遍历方式可以用于深度优先搜索。

非递归实现（preorderIterative函数）：

2中序遍历（Inorder Traversal）：中序遍历的顺序是左子树 -> 根节点 -> 右子树。

3后序遍历（Postorder Traversal）：后序遍历的顺序是左子树 -> 右子树 -> 根节点。

4层序遍历（Level Order Traversal）：层序遍历按照从上到下、从左到右的顺序遍历每一层的节点。

5深度优先遍历（Depth-First Traversal）：深度优先遍历是一种通用的遍历方式，可以根据需要选择前序、中序、后序遍历方式。

---

以下是C++中二叉树前序、中序、后序遍历的递归和非递归实现，以及层序遍历和深度优先遍历的代码和讲解。

二叉树节点结构：

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

1.1 前序遍历（Preorder Traversal）：

前序遍历的顺序是根节点 -> 左子树 -> 右子树。

• 递归实现（preorderRecursive函数）：首先访问当前节点，然后递归遍历左子树，最后递归遍历右子树。这种遍历方式可以用于深度优先搜索。

• void preorderRecursive(TreeNode* root) {if (root == NULL) return;cout << root->val << " ";preorderRecursive(root->left);preorderRecursive(root->right);
  }
  

• 非递归实现（preorderIterative函数）：

• 使用一个栈来模拟递归，首先将根节点入栈，然后循环直到栈为空。在循环内，将栈顶节点出栈并访问，然后将右子节点和左子节点（如果存在）依次入栈，以确保下一次出栈的是左子节点。这样可以按照根-左-右的顺序遍历树。

void preorderIterative(TreeNode* root) {if (root == NULL) return;stack<TreeNode*> s;s.push(root);while (!s.empty()) {TreeNode* node = s.top();s.pop();cout << node->val << " ";if (node->right) s.push(node->right);if (node->left) s.push(node->left);}
}

1. 2中序遍历（Inorder Traversal）：中序遍历的顺序是左子树 -> 根节点 -> 右子树。

   • 递归实现（inorderRecursive函数）：首先递归遍历左子树，然后访问当前节点，最后递归遍历右子树。中序遍历可以按照从小到大的顺序遍历二叉搜索树的所有节点。

     void inorderRecursive(TreeNode* root) {if (root == NULL) return;inorderRecursive(root->left);cout << root->val << " ";inorderRecursive(root->right);
     }
     

   • 非递归实现（inorderIterative函数）：使用一个栈来模拟递归，从根节点出发，每次将当前节点以及所有左子节点入栈，然后出栈并访问节点，再处理右子节点。这样可以按照左-根-右的顺序遍历树。

     void inorderIterative(TreeNode* root) {stack<TreeNode*> s;TreeNode* curr = root;while (curr || !s.empty()) {while (curr) {s.push(curr);curr = curr->left;}curr = s.top();s.pop();cout << curr->val << " ";curr = curr->right;}
     }
     

2. 3后序遍历（Postorder Traversal）：后序遍历的顺序是左子树 -> 右子树 -> 根节点。

   • 递归实现（postorderRecursive函数）：首先递归遍历左子树，然后递归遍历右子树，最后访问当前节点。后序遍历通常用于内存管理和资源释放。

     void postorderRecursive(TreeNode* root) {if (root == NULL) return;postorderRecursive(root->left);postorderRecursive(root->right);cout << root->val << " ";
     }
     

   • 非递归实现（postorderIterative函数）：需要两个栈，一个用于遍历，另一个用于输出。首先将根节点入遍历栈，然后在循环中，出栈并压入输出栈，然后将左子节点和右子节点分别压入遍历栈。最后，从输出栈中依次出栈并访问节点，得到后序遍历的结果。

     void postorderIterative(TreeNode* root) {if (root == NULL) return;stack<TreeNode*> s;stack<TreeNode*> output;s.push(root);while (!s.empty()) {TreeNode* node = s.top();s.pop();output.push(node);if (node->left) s.push(node->left);if (node->right) s.push(node->right);}while (!output.empty()) {TreeNode* node = output.top();output.pop();cout << node->val << " ";}
     }
     

3. 4层序遍历（Level Order Traversal）：层序遍历按照从上到下、从左到右的顺序遍历每一层的节点。

   • 使用队列来实现。从根节点开始，将节点入队列，然后在循环中出队列并访问节点，同时将其子节点入队列。这样可以按照树的层级顺序遍历。

     void levelOrder(TreeNode* root) {if (root == NULL) return;queue<TreeNode*> q;q.push(root);while (!q.empty()) {TreeNode* node = q.front();q.pop();cout << node->val << " ";if (node->left) q.push(node->left);if (node->right) q.push(node->right);}
     }
     

4. 5深度优先遍历（Depth-First Traversal）：深度优先遍历是一种通用的遍历方式，可以根据需要选择前序、中序、后序遍历方式。

   • 深度优先遍历是一种通用的遍历方法，可以根据需要选择前序、中序、后序遍历方式。在示例中，使用前序遍历的方式进行深度优先遍历。深度优先遍历通过栈来实现，首先将根节点入栈，然后在循环中出栈并访问节点，同时将右子节点和左子节点（按照栈的特性，右子节点先入栈）依次入栈，以确保下一次出栈的是左子节点。

     void depthFirst(TreeNode* root) {if (root == NULL) return;stack<TreeNode*> s;s.push(root);while (!s.empty()) {TreeNode* node = s.top();s.pop();cout << node->val << " ";if (node->right) s.push(node->right);if (node->left) s.push(node->left);}
     }