如何在不使用递归的情况下在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;

typedef struct Queue {
    QueueNode* front;
    QueueNode* rear;
} Queue;

Queue* createQueue() {
    Queue* queue = (Queue*)malloc(sizeof(Queue));
    queue->front = NULL;
    queue->rear = NULL;
    return queue;
}

void enqueue(Queue* queue, TreeNode* node) {
    QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
    newNode->node = node;
    newNode->next = NULL;
    
    if (queue->rear == NULL) {
        queue->front = newNode;
        queue->rear = newNode;
    } else {
        queue->rear->next = newNode;
        queue->rear = newNode;
    }
}

TreeNode* dequeue(Queue* queue) {
    if (queue->front == NULL) {
        return NULL;
    }
    
    TreeNode* node = queue->front->node;
    QueueNode* temp = queue->front;
    queue->front = queue->front->next;
    
    if (queue->front == NULL) {
        queue->rear = NULL;
    }
    
    free(temp);
    return node;
}

int getBinaryTreeHeight(TreeNode* root) {
    if (root == NULL) {
        return 0;
    }
    
    Queue* queue = createQueue();
    enqueue(queue, root);
    int height = 0;
    
    while (1) {
        int levelSize = queue->rear - queue->front + 1;
        if (levelSize == 0) {
            break;
        }
        
        while (levelSize > 0) {
            TreeNode* node = dequeue(queue);
            
            if (node->left != NULL) {
                enqueue(queue, node->left);
            }
            
            if (node->right != NULL) {
                enqueue(queue, node->right);
            }
            
            levelSize--;
        }
        
        height++;
    }
    
    return height;
}

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 = (TreeNode*)malloc(sizeof(TreeNode));
    root->left->left->val = 4;
    
    root->left->right = (TreeNode*)malloc(sizeof(TreeNode));
    root->left->right->val = 5;
    
    root->right->left = (TreeNode*)malloc(sizeof(TreeNode));
    root->right->left->val = 6;
    
    root->right->right = (TreeNode*)malloc(sizeof(TreeNode));
    root->right->right->val = 7;
    
    // 计算二叉树的高度
    int height = getBinaryTreeHeight(root);
    printf("二叉树的高度为：%d\n", height);
    
    // 释放内存
    free(root->right->right);
    free(root->right->left);
    free(root->left->right);
    free(root->left->left);
    free(root->right);
    free(root->left);
    free(root);
    
    return 0;
}