Python实现二叉树遍历
# 定义二叉树节点类
class TreeNode:
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
# 前序遍历(非递归)
def preorderTraversal(root):
if not root:
return []
stack, output = [root], []
while stack:
node = stack.pop()
if node:
output.append(node.val)
if node.right:
stack.append(node.right)
if node.left:
stack.append(node.left)
return output
# 中序遍历(非递归)
def inorderTraversal(root):
stack, output, current = [], [], root
while True:
while current:
stack.append(current)
current = current.left
if not stack:
return output
current = stack.pop()
output.append(current.val)
current = current.right
# 后序遍历(非递归)
def postorderTraversal(root):
if not root:
return []
stack1, stack2, output = [root], [], []
while stack1:
node = stack1.pop()
if node:
stack2.append(node)
if node.left:
stack1.append(node.left)
if node.right:
stack1.append(node.right)
while stack2:
node = stack2.pop()
output.append(node.val)
return output[::-1] # 逆序输出,得到后序遍历结果
# 层次遍历(非递归)
def levelOrderTraversal(root):
if not root:
return []
from collections import deque
queue, output = deque([root]), []
while queue:
level_size = len(queue)
current_level = []
for _ in range(level_size):
node = queue.popleft() # 弹出队列左侧元素
current_level.append(node.val)
if node.left:
queue.append(node.left) # 左孩子入队
if node.right:
queue.append(node.right) # 右孩子入队
output.append(current_level)
return output
cpp实现二叉树遍历
#include <iostream>
#include <stack>
#include <queue>
using namespace std;
// 二叉树节点定义
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
// 前序遍历(递归实现)
void preorderTraversalRecursive(TreeNode* root) {
if (root == NULL) {
return;
}
cout << root->val << " ";
preorderTraversalRecursive(root->left);
preorderTraversalRecursive(root->right);
}
// 前序遍历(迭代实现)
void preorderTraversalIterative(TreeNode* root) {
if (root == NULL) {
return;
}
stack<TreeNode*> stk;
stk.push(root);
while (!stk.empty()) {
TreeNode* node = stk.top();
stk.pop();
cout << node->val << " ";
if (node->right != NULL) {
stk.push(node->right);
}
if (node->left != NULL) {
stk.push(node->left);
}
}
}
// 中序遍历(递归实现)
void inorderTraversalRecursive(TreeNode* root) {
if (root == NULL) {
return;
}
inorderTraversalRecursive(root->left);
cout << root->val << " ";
inorderTraversalRecursive(root->right);
}
// 中序遍历(迭代实现)
void inorderTraversalIterative(TreeNode* root) {
if (root == NULL) {
return;
}
stack<TreeNode*> stk;
TreeNode* curr = root;
while (curr != NULL || !stk.empty()) {
while (curr != NULL) {
stk.push(curr);
curr = curr->left;
}
curr = stk.top();
stk.pop();
cout << curr->val << " ";
curr = curr->right;
}
}
// 后序遍历(递归实现)
void postorderTraversalRecursive(TreeNode* root) {
if (root == NULL) {
return;
}
postorderTraversalRecursive(root->left);
postorderTraversalRecursive(root->right);
cout << root->val << " ";
}
// 后序遍历(迭代实现)
void postorderTraversalIterative(TreeNode* root) {
if (root == NULL) {
return;
}
stack<TreeNode*> stk1, stk2;
stk1.push(root);
while (!stk1.empty()) {
TreeNode* node = stk1.top();
stk1.pop();
stk2.push(node);
if (node->left != NULL) {
stk1.push(node->left);
}
if (node->right != NULL) {
stk1.push(node->right);
}
}
while (!stk2.empty()) {
cout << stk2.top()->val << " ";
stk2.pop();
}
}
// 层次遍历
void levelOrderTraversal(TreeNode* root) {
if (root == NULL) {
return;
}
queue<TreeNode*> q;
q.push(root);
while (!q.empty()) {
int levelSize = q.size();
for (int i = 0; i < levelSize; i++) {
TreeNode* node = q.front();
q.pop();
cout << node->val << " ";
if (node->left != NULL) {
q.push(node->left);
}
if (node->right != NULL) {
q.push(node->right);
}
}
cout << endl; // 每一层遍历完后换行
}
int main() {
// 创建二叉树
TreeNode* root = new TreeNode(1);
root->left = new TreeNode(2);
root->right = new TreeNode(3);
root->left->left = new TreeNode(4);
root->left->right = new TreeNode(5);
root->right->left = new TreeNode(6);
root->right->right = new TreeNode(7);
cout << "前序遍历(递归实现): ";
preorderTraversalRecursive(root); cout << endl; // 输出:1 2 4 5 3 6 7
}
水平有限,有问题随时联系~