6-1 二叉树的遍历c语言代码

以下是二叉树的遍历（先序、中序、后序）的C语言代码示例：

1.先序遍历
void preOrder(struct TreeNode* root){
if(root == NULL)
return;
printf("%d ", root->val);
preOrder(root->left);
preOrder(root->right);
}

2.中序遍历
void inOrder(struct TreeNode* root){
if(root == NULL)
return;
inOrder(root->left);
printf("%d ", root->val);
inOrder(root->right);
}

3.后序遍历
void postOrder(struct TreeNode* root){
if(root == NULL)
return;
postOrder(root->left);
postOrder(root->right);
printf("%d ", root->val);
}

相关问题

二叉树遍历c语言代码

以下是二叉树的前序、中序和后序遍历的 C 语言代码：

// 二叉树结构体
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

// 前序遍历
void preorderTraversal(struct TreeNode* root) {
    if (root == NULL) {
        return;
    }
    printf("%d ", root->val); // 先访问根节点
    preorderTraversal(root->left); // 再递归访问左子树
    preorderTraversal(root->right); // 最后递归访问右子树
}

// 中序遍历
void inorderTraversal(struct TreeNode* root) {
    if (root == NULL) {
        return;
    }
    inorderTraversal(root->left); // 先递归访问左子树
    printf("%d ", root->val); // 再访问根节点
    inorderTraversal(root->right); // 最后递归访问右子树
}

// 后序遍历
void postorderTraversal(struct TreeNode* root) {
    if (root == NULL) {
        return;
    }
    postorderTraversal(root->left); // 先递归访问左子树
    postorderTraversal(root->right); // 再递归访问右子树
    printf("%d ", root->val); // 最后访问根节点
}

以上代码中，`struct TreeNode` 是二叉树的结构体，包含了一个值 `val` 和左右子树的指针 `left` 和 `right`。`preorderTraversal`、`inorderTraversal`、`postorderTraversal` 分别是前序、中序和后序遍历的函数，其中使用了递归实现。

二叉树层序遍历C语言代码

### 回答1：

二叉树层序遍历C语言代码的一个实现可能如下：#include <stdio.h>
#include <stdlib.h>struct node{
int data;
struct node *left;
struct node *right;
};void LevelOrder(struct node *root)
{
int rear,front;
struct node *queue[20];
struct node *temp;
rear = front = 0;
if(root == NULL) return;
queue[rear] = root;
rear++;
while(front != rear)
{
temp = queue[front];
front++;
printf("%d ",temp->data);
if(temp->left)
{
queue[rear] = temp->left;
rear++;
}
if(temp->right)
{
queue[rear] = temp->right;
rear++;
}
}
}int main()
{
struct node *root = NULL;
LevelOrder(root);
return 0;
}

### 回答2：
二叉树的层序遍历是一种广度优先搜索算法，通过按层级遍历二叉树的节点。下面是用C语言实现二叉树层序遍历的代码：

#include <stdio.h>
#include <stdlib.h>

// 二叉树节点的定义
typedef struct Node {
    int data;
    struct Node* left;
    struct Node* right;
} Node;

// 创建一个新的二叉树节点
Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->left = NULL;
    newNode->right = NULL;
    return newNode;
}

// 层序遍历方法
void levelOrderTraversal(Node* root) {
    if (root == NULL) {
        return;
    }
    
    // 创建一个队列用于存储节点
    Node** queue = (Node**)malloc(sizeof(Node*));
    int front = 0;
    int rear = 0;
    
    // 将根节点入队列
    queue[rear] = root;
    rear++;
    
    // 循环遍历队列，直到队列为空
    while (front < rear) {
        // 从队列中取出节点并打印
        Node* currentNode = queue[front];
        printf("%d ", currentNode->data);
        front++;
        
        // 如果当前节点有左孩子，将左孩子入队列
        if (currentNode->left != NULL) {
            queue = (Node**)realloc(queue, (rear + 1) * sizeof(Node*));
            queue[rear] = currentNode->left;
            rear++;
        }
        
        // 如果当前节点有右孩子，将右孩子入队列
        if (currentNode->right != NULL) {
            queue = (Node**)realloc(queue, (rear + 1) * sizeof(Node*));
            queue[rear] = currentNode->right;
            rear++;
        }
    }
    
    // 释放队列内存空间
    free(queue);
}

// 主函数
int main() {
    // 创建一个二叉树
    Node* root = createNode(1);
    root->left = createNode(2);
    root->right = createNode(3);
    root->left->left = createNode(4);
    root->left->right = createNode(5);
    
    // 输出二叉树层序遍历结果
    printf("二叉树层序遍历结果: ");
    levelOrderTraversal(root);
    
    return 0;
}

上述代码首先定义了一个二叉树节点的结构，其中包括节点的值以及左右子节点的指针。然后定义了一个创建新节点的函数，用于动态分配内存并初始化节点的值和指针。

接下来是层序遍历的函数`levelOrderTraversal`，它使用一个队列进行遍历。首先将根节点入队列，然后循环遍历队列，取出队列中的节点并打印它们的值。同时，将每个节点的左右子节点也入队列，直到队列为空为止。

最后，在主函数中创建了一个二叉树，并调用层序遍历函数来输出遍历结果。

### 回答3：
二叉树的层序遍历是一种广度优先搜索算法，即逐层地访问树中的节点。以下是用C语言实现二叉树层序遍历的代码：

#include <stdio.h>
#include <stdlib.h>

// 定义二叉树节点的结构体
typedef struct TreeNode {
    int val; // 节点值
    struct TreeNode* left; // 左子节点指针
    struct TreeNode* right; // 右子节点指针
} TreeNode;

// 定义队列的结构体
typedef struct QueueNode {
    TreeNode* node; // 节点指针
    struct QueueNode* next; // 下一个节点指针
} QueueNode;

// 入队
void enqueue(QueueNode** rear, TreeNode* node) {
    QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
    newNode->node = node;
    newNode->next = NULL;
    
    if (*rear == NULL) {
        *rear = newNode;
    } else {
        (*rear)->next = newNode;
        *rear = newNode;
    }
}

// 出队
TreeNode* dequeue(QueueNode** front) {
    if (*front == NULL) {
        return NULL;
    }
    
    QueueNode* temp = *front;
    TreeNode* node = temp->node;
    *front = (*front)->next;
    
    free(temp);
    return node;
}

// 二叉树层序遍历
void levelOrderTraversal(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    
    QueueNode* queue = NULL;
    QueueNode* rear = NULL;
    
    enqueue(&rear, root);
    
    while (queue != NULL) {
        TreeNode* node = dequeue(&queue);
        printf("%d ", node->val);
        
        if (node->left != NULL) {
            enqueue(&rear, node->left);
        }
        
        if (node->right != NULL) {
            enqueue(&rear, node->right);
        }
    }
}

int main() {
    // 创建一个二叉树
    TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));
    root->val = 1;
    root->left = (TreeNode*)malloc(sizeof(TreeNode));
    root->left->val = 2;
    root->right = (TreeNode*)malloc(sizeof(TreeNode));
    root->right->val = 3;
    root->left->left = NULL;
    root->left->right = NULL;
    root->right->left = NULL;
    root->right->right = NULL;
    
    // 层序遍历二叉树
    levelOrderTraversal(root);
    
    return 0;
}

以上代码定义了二叉树节点的结构体和队列的结构体，并实现了入队enqueue和出队dequeue操作。在层序遍历函数levelOrderTraversal中，首先将根节点入队，然后进入循环，每次出队，输出节点值，并将其左右子节点入队，直至队列为空。最后，在main函数中创建一个二叉树并调用层序遍历函数进行测试。