写一个二叉树的遍历代码

下面的代码可以用来遍历二叉树：/**
* 二叉树的遍历
*/
void traverseTree(Node* root) {
// 先序遍历
if (root != NULL) {
printf("%d", root->val);
traverseTree(root->left);
traverseTree(root->right);
}
}

相关问题

还是帮我写一个二叉树遍历代码吧

### 回答1：
好的，以下是二叉树的中序遍历代码：

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

希望能对您有所帮助。

### 回答2：
二叉树的遍历是指按照一定的顺序访问二叉树中的所有节点，常见的遍历方式有前序遍历、中序遍历和后序遍历。

下面是一个简单的二叉树遍历的代码示例：

# 定义二叉树节点的类
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

# 前序遍历二叉树（根-左-右）
def preorder_traversal(root):
    if not root:
        return
    print(root.val)  # 遍历当前节点
    preorder_traversal(root.left)  # 遍历左子树
    preorder_traversal(root.right)  # 遍历右子树

# 中序遍历二叉树（左-根-右）
def inorder_traversal(root):
    if not root:
        return
    inorder_traversal(root.left)  # 遍历左子树
    print(root.val)  # 遍历当前节点
    inorder_traversal(root.right)  # 遍历右子树

# 后序遍历二叉树（左-右-根）
def postorder_traversal(root):
    if not root:
        return
    postorder_traversal(root.left)  # 遍历左子树
    postorder_traversal(root.right)  # 遍历右子树
    print(root.val)  # 遍历当前节点

# 创建一个二叉树
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)

# 调用不同的遍历函数
print("前序遍历结果：")
preorder_traversal(root)

print("中序遍历结果：")
inorder_traversal(root)

print("后序遍历结果：")
postorder_traversal(root)

以上代码实现了一个二叉树的遍历功能，分别输出了前序遍历、中序遍历和后序遍历的结果。你可以根据具体的需求选择相应的遍历方式。

### 回答3：
当然，下面是一个简单的二叉树的先序遍历代码示例：

# 定义二叉树节点类
class TreeNode:
    def __init__(self, value):
        self.val = value
        self.left = None
        self.right = None

# 定义先序遍历函数
def preorderTraversal(root):
    if root is None: # 如果根节点为空，则返回
        return []
    stack = [] # 使用栈来辅助遍历
    result = [] # 保存遍历的结果
    stack.append(root)
    while stack:
        node = stack.pop()
        result.append(node.val)
        if node.right: # 先把右子树加入栈，因为栈是先入后出的顺序
            stack.append(node.right)
        if node.left: # 后加左子树
            stack.append(node.left)
    return result

# 创建二叉树
'''
    1
   / \
  2   3
 / \   \
4   5   6  
'''
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)
root.left.left = TreeNode(4)
root.left.right = TreeNode(5)
root.right.right = TreeNode(6)

# 调用先序遍历函数
result = preorderTraversal(root)
print(result)  # 输出：[1, 2, 4, 5, 3, 6]

以上代码实现了二叉树的先序遍历（根左右）功能，并采用了栈作为辅助数据结构来实现遍历的过程。

写一段二叉树遍历的代码

以下是二叉树遍历的代码，包括先序遍历、中序遍历和后序遍历：

# 定义二叉树的节点
class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

# 先序遍历
def preorderTraversal(root):
    if not root:
        return []
    res = []
    stack = [root]
    while stack:
        node = stack.pop()
        res.append(node.val)
        if node.right:
            stack.append(node.right)
        if node.left:
            stack.append(node.left)
    return res

# 中序遍历
def inorderTraversal(root):
    if not root:
        return []
    res = []
    stack = []
    node = root
    while stack or node:
        while node:
            stack.append(node)
            node = node.left
        node = stack.pop()
        res.append(node.val)
        node = node.right
    return res

# 后序遍历
def postorderTraversal(root):
    if not root:
        return []
    res = []
    stack = [root]
    while stack:
        node = stack.pop()
        res.append(node.val)
        if node.left:
            stack.append(node.left)
        if node.right:
            stack.append(node.right)
    return res[::-1]

其中，先序遍历使用了栈进行迭代，中序遍历使用了栈和指针进行迭代，后序遍历使用了栈进行迭代，并且最后将结果翻转。