判断一棵树是否为完全二叉树的C语言算法。

以下是判断一棵树是否为完全二叉树的C语言算法：

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

/* 树结点的定义 */
typedef struct TreeNode {
    int data;
    struct TreeNode *left;
    struct TreeNode *right;
} TreeNode;

/* 队列结点的定义 */
typedef struct QueueNode {
    TreeNode *data;
    struct QueueNode *next;
} QueueNode;

/* 队列的定义 */
typedef struct Queue {
    QueueNode *front;
    QueueNode *rear;
} Queue;

/* 创建一个新的树结点 */
TreeNode *newTreeNode(int data) {
    TreeNode *node = (TreeNode *)malloc(sizeof(TreeNode));
    node->data = data;
    node->left = NULL;
    node->right = NULL;
    return node;
}

/* 创建一个新的队列结点 */
QueueNode *newQueueNode(TreeNode *node) {
    QueueNode *qnode = (QueueNode *)malloc(sizeof(QueueNode));
    qnode->data = node;
    qnode->next = NULL;
    return qnode;
}

/* 创建一个新的队列 */
Queue *newQueue() {
    Queue *queue = (Queue *)malloc(sizeof(Queue));
    queue->front = NULL;
    queue->rear = NULL;
    return queue;
}

/* 判断队列是否为空 */
bool isQueueEmpty(Queue *queue) {
    return (queue->front == NULL);
}

/* 入队 */
void enqueue(Queue *queue, TreeNode *node) {
    QueueNode *qnode = newQueueNode(node);
    if (isQueueEmpty(queue)) {
        queue->front = qnode;
        queue->rear = qnode;
    } else {
        queue->rear->next = qnode;
        queue->rear = qnode;
    }
}

/* 出队 */
TreeNode *dequeue(Queue *queue) {
    if (isQueueEmpty(queue)) {
        return NULL;
    } else {
        QueueNode *qnode = queue->front;
        TreeNode *node = qnode->data;
        queue->front = queue->front->next;
        if (queue->front == NULL) {
            queue->rear = NULL;
        }
        free(qnode);
        return node;
    }
}

/* 判断一棵树是否为完全二叉树 */
bool isCompleteBinaryTree(TreeNode *root) {
    if (root == NULL) {
        return true;
    }
    Queue *queue = newQueue();
    enqueue(queue, root);
    bool flag = false;
    while (!isQueueEmpty(queue)) {
        TreeNode *node = dequeue(queue);
        if (node->left != NULL) {
            if (flag) {
                return false;
            }
            enqueue(queue, node->left);
        } else {
            flag = true;
        }
        if (node->right != NULL) {
            if (flag) {
                return false;
            }
            enqueue(queue, node->right);
        } else {
            flag = true;
        }
    }
    return true;
}

/* 测试 */
int main() {
    TreeNode *root = newTreeNode(1);
    root->left = newTreeNode(2);
    root->right = newTreeNode(3);
    root->left->left = newTreeNode(4);
    root->left->right = newTreeNode(5);
    root->right->left = newTreeNode(6);
    if (isCompleteBinaryTree(root)) {
        printf("The tree is a complete binary tree.\n");
    } else {
        printf("The tree is not a complete binary tree.\n");
    }
    return 0;
}

该算法使用队列进行层次遍历，对于每个结点，如果它的左子结点不为空，则将左子结点入队；如果它的左子结点为空，则标记为“不完全结点”；如果它的右子结点不为空，且已经标记为“不完全结点”，则该树不是完全二叉树；否则，将右子结点入队。如果队列为空，则该树是完全二叉树。