c++语言进行层次遍历二叉树

好的，我可以回答这个问题。在C语言中，可以使用队列来实现层次遍历二叉树。具体的实现步骤为：首先将根节点入队，然后循环执行以下步骤，直到队列为空：取出队首元素，输出该节点的值，并将其左右子节点依次入队。这样就完成了二叉树的层次遍历。

相关问题

以二叉链表作为二叉树的存储结构，用C++语言编写用层次顺序遍历二叉树的方法，统计树中度为1 的结点个数。

以下是C++的代码实现：

#include <iostream>
#include <queue>

using namespace std;

// 二叉树的结点结构体
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

// 统计二叉树中度为1的结点个数
int countDegreeOne(TreeNode* root) {
    if (root == NULL)
        return 0;
    queue<TreeNode*> q;
    q.push(root);
    int count = 0;
    while (!q.empty()) {
        TreeNode* node = q.front();
        q.pop();
        if ((node->left == NULL && node->right != NULL) || (node->left != NULL && node->right == NULL))
            count++;
        if (node->left != NULL)
            q.push(node->left);
        if (node->right != NULL)
            q.push(node->right);
    }
    return count;
}

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);

    // 统计度为1的结点个数
    int count = countDegreeOne(root);
    cout << "Degree 1 nodes count: " << count << endl;

    return 0;
}

在这个代码中，我们使用了队列来进行层次顺序遍历二叉树。在遍历过程中，如果一个结点的左子树或右子树为空，但是另一侧子树不为空，那么这个结点的度为1，累加计数器即可。

用C++语言写一个二叉树的基本操作代码，包括前中后遍历，层次遍历，子叶数，结点数。层次遍历使用队列

二叉树基本操作代码如下：

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

typedef struct Node {
    int value;
    struct Node* left;
    struct Node* right;
} Node;

// 创建节点
Node* createNode(int value) {
    Node* node = (Node*)malloc(sizeof(Node));
    node->value = value;
    node->left = NULL;
    node->right = NULL;
    return node;
}

// 插入节点
Node* insert(Node* root, int value) {
    if (root == NULL) {
        return createNode(value);
    }
    if (value < root->value) {
        root->left = insert(root->left, value);
    } else if (value > root->value) {
        root->right = insert(root->right, value);
    }
    return root;
}

// 前序遍历
void preOrder(Node* root) {
    if (root != NULL) {
        printf("%d ", root->value);
        preOrder(root->left);
        preOrder(root->right);
    }
}

// 中序遍历
void inOrder(Node* root) {
    if (root != NULL) {
        inOrder(root->left);
        printf("%d ", root->value);
        inOrder(root->right);
    }
}

// 后序遍历
void postOrder(Node* root) {
    if (root != NULL) {
        postOrder(root->left);
        postOrder(root->right);
        printf("%d ", root->value);
    }
}

// 层次遍历
void levelOrder(Node* root) {
    if (root == NULL) {
        return;
    }
    Node* queue[100];
    int front = 0;
    int rear = 0;
    queue[rear++] = root;
    while (front != rear) {
        Node* node = queue[front++];
        printf("%d ", node->value);
        if (node->left != NULL) {
            queue[rear++] = node->left;
        }
        if (node->right != NULL) {
            queue[rear++] = node->right;
        }
    }
}

// 计算子叶数
int leafCount(Node* root) {
    if (root == NULL) {
        return 0;
    }
    if (root->left == NULL && root->right == NULL) {
        return 1;
    }
    return leafCount(root->left) + leafCount(root->right);
}

// 计算结点数
int nodeCount(Node* root) {
    if (root == NULL) {
        return 0;
    }
    return nodeCount(root->left) + nodeCount(root->right) + 1;
}

int main() {
    Node* root = NULL;
    int values[] = { 5, 2, 8, 1, 3, 7, 9 };
    int n = sizeof(values) / sizeof(values[0]);
    for (int i = 0; i < n; i++) {
        root = insert(root, values[i]);
    }
    printf("前序遍历：");
    preOrder(root);
    printf("\n中序遍历：");
    inOrder(root);
    printf("\n后序遍历：");
    postOrder(root);
    printf("\n层次遍历：");
    levelOrder(root);
    printf("\n子叶数：%d", leafCount(root));
    printf("\n结点数：%d", nodeCount(root));
    return 0;
}

注意：此代码中的队列实现方式不是线程安全的，仅用于演示二叉树的层次遍历。如果需要在多线程环境中使用，请使用线程安全的队列实现。