c语言写二叉树层序遍历算法

可以使用队列来实现二叉树的层序遍历算法。具体步骤如下：

1. 将根节点入队列。
2. 当队列不为空时，取出队首元素，输出该节点的值。
3. 如果该节点有左子节点，则将左子节点入队列。
4. 如果该节点有右子节点，则将右子节点入队列。
5. 重复步骤2-4，直到队列为空。

代码实现如下：

void levelOrderTraversal(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 != NULL) {
            q.push(node->left);
        }
        if (node->right != NULL) {
            q.push(node->right);
        }
    }
}

相关问题

C语言二叉树层序遍历

C语言中二叉树的层序遍历是一种广度优先搜索算法，它按照从上到下、从左到右的顺序遍历二叉树的每个节点。具体实现可以使用队列来辅助实现。具体步骤如下：
1. 首先将根节点入队。
2. 当队列不为空时，取出队首元素，输出该节点的值，并将其左右子节点（如果有）入队。
3. 重复步骤2，直到队列为空。

下面是一个示例代码，其中levelwise函数实现了二叉树的层序遍历：

void levelwise(BTnodePtr root) {
    if (root == NULL) {
        return;
    }
    QueuePtr queue = (QueuePtr)malloc(sizeof(struct BTNodePtrQueue));
    queue->nodePtrs = (BTnodePtr*)malloc(sizeof(BTnodePtr) * MAX_QUEUE_SIZE);
    queue->front = 0;
    queue->rear = -1;
    enqueue(queue, root);
    while (!isEmpty(queue)) {
        BTnodePtr node = dequeue(queue);
        printf("%c ", node->element);
        if (node->left != NULL) {
            enqueue(queue, node->left);
        }
        if (node->right != NULL) {
            enqueue(queue, node->right);
        }
    }
    free(queue->nodePtrs);
    free(queue);
}

c语言二叉树层序遍历

二叉树的层序遍历是一种广度优先搜索算法，它按照层的顺序遍历二叉树的节点。下面是C语言实现二叉树层序遍历的代码：

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

// 二叉树的结构体
typedef struct BTnode {
    char element;
    struct BTnode *left;
    struct BTnode *right;
} *BTnodePtr;

// 队列的结构体
typedef struct Queue {
    BTnodePtr *data;
    int front, rear;
    int maxSize;
} *QueuePtr;

// 初始化队列
QueuePtr initQueue(int maxSize) {
    QueuePtr q = (QueuePtr)malloc(sizeof(struct Queue));
    q->data = (BTnodePtr*)malloc(sizeof(BTnodePtr) * maxSize);
    q->front = q->rear = 0;
    q->maxSize = maxSize;
    return q;
}

// 判断队列是否为空
int isEmpty(QueuePtr q) {
    return q->front == q->rear;
}

// 添加元素
void enqueue(QueuePtr q, BTnodePtr x) {
    if ((q->rear + 1) % q->maxSize == q->front) {
        printf("Queue is full.\n");
        return;
    }
    q->data[q->rear] = x;
    q->rear = (q->rear + 1) % q->maxSize;
}

// 删除元素
BTnodePtr dequeue(QueuePtr q) {
    if (isEmpty(q)) {
        printf("Queue is empty.\n");
        return NULL;
    }
    BTnodePtr x = q->data[q->front];
    q->front = (q->front + 1) % q->maxSize;
    return x;
}

// 创建结点
BTnodePtr createNode(char element) {
    BTnodePtr node = (BTnodePtr)malloc(sizeof(struct BTnode));
    node->element = element;
    node->left = node->right = NULL;
    return node;
}

// 创建二叉树
BTnodePtr createTree() {
    BTnodePtr root = createNode('A');
    root->left = createNode('B');
    root->right = createNode('C');
    root->left->left = createNode('D');
    root->left->right = createNode('E');
    root->right->left = createNode('F');
    root->right->right = createNode('G');
    return root;
}

// 层次遍历
void levelOrder(BTnodePtr root) {
    QueuePtr q = initQueue(100);
    enqueue(q, root);
    while (!isEmpty(q)) {
        BTnodePtr node = dequeue(q);
        printf("%c ", node->element);
        if (node->left != NULL) {
            enqueue(q, node->left);
        }
        if (node->right != NULL) {
            enqueue(q, node->right);
        }
    }
}

// 主函数
int main() {
    BTnodePtr root = createTree();
    printf("Level order traversal of binary tree is: ");
    levelOrder(root);
    printf("\n");
    return 0;
}