1. PingCode智库首页
  2. 百科

如何用c语言求树高

Edit1 • • 百科

如何用c语言求树高

用C语言求树高的方法有递归法、非递归法、广度优先遍历法等。 其中，递归法是最常用且直观的方法，它通过递归函数逐层计算树的高度。递归法的核心在于利用树的分治特性，将问题分解成子问题。接下来，我将详细介绍递归法求树高的具体实现。

一、递归法计算树高

递归法是通过递归函数来逐层计算树的高度。其基本思想是：树的高度等于左子树和右子树高度的最大值加1。具体实现步骤如下：

  1. 定义树的结构：首先定义树的节点结构。
  2. 实现递归函数：编写递归函数，计算每个节点的高度。
  3. 调用递归函数：在主函数中调用递归函数，计算整棵树的高度。

1. 定义树的结构

在C语言中，可以用结构体来定义树的节点。每个节点包含数据域、左子树指针和右子树指针。以下是树节点的定义：

#include <stdio.h>


#include <stdlib.h>


struct TreeNode {


    int data;


    struct TreeNode *left;


    struct TreeNode *right;


};

2. 实现递归函数

递归函数的核心思想是：如果节点为空，则高度为0；否则，高度为左子树和右子树高度的最大值加1。以下是递归函数的实现：

int max(int a, int b) {


    return (a > b) ? a : b;


}


int height(struct TreeNode *node) {


    if (node == NULL)


        return 0;


    else {


        int leftHeight = height(node->left);


        int rightHeight = height(node->right);


        return max(leftHeight, rightHeight) + 1;


    }


}

3. 调用递归函数

在主函数中构建树，并调用递归函数计算树的高度。以下是完整的示例代码：

int main() {


    struct TreeNode *root = (struct TreeNode *)malloc(sizeof(struct TreeNode));


    root->data = 1;


    root->left = (struct TreeNode *)malloc(sizeof(struct TreeNode));


    root->left->data = 2;


    root->right = (struct TreeNode *)malloc(sizeof(struct TreeNode));


    root->right->data = 3;


    root->left->left = (struct TreeNode *)malloc(sizeof(struct TreeNode));


    root->left->left->data = 4;


    root->left->right = (struct TreeNode *)malloc(sizeof(struct TreeNode));


    root->left->right->data = 5;


    printf("Height of tree is %dn", height(root));


    // Free allocated memory


    free(root->left->right);


    free(root->left->left);


    free(root->right);


    free(root->left);


    free(root);


    return 0;


}

二、非递归法计算树高

非递归法利用栈或队列来模拟递归过程。相比递归法，非递归法可以避免函数调用的开销和栈溢出的问题。以下是非递归法的具体实现：

1. 用栈计算树高

栈是一种后进先出的数据结构，可以用来模拟递归过程。以下是用栈计算树高的实现：

#include <stdio.h>


#include <stdlib.h>


struct TreeNode {


    int data;


    struct TreeNode *left;


    struct TreeNode *right;


};


struct StackNode {


    struct TreeNode *treeNode;


    int depth;


    struct StackNode *next;


};


void push(struct StackNode stack, struct TreeNode *treeNode, int depth) {


    struct StackNode *newNode = (struct StackNode *)malloc(sizeof(struct StackNode));


    newNode->treeNode = treeNode;


    newNode->depth = depth;


    newNode->next = *stack;


    *stack = newNode;


}


struct StackNode *pop(struct StackNode stack) {


    struct StackNode *top = *stack;


    if (top != NULL) {


        *stack = top->next;


    }


    return top;


}


int height(struct TreeNode *root) {


    if (root == NULL) return 0;


    struct StackNode *stack = NULL;


    push(&stack, root, 1);


    int maxDepth = 0;


    while (stack != NULL) {


        struct StackNode *node = pop(&stack);


        if (node != NULL) {


            struct TreeNode *treeNode = node->treeNode;


            int depth = node->depth;


            if (treeNode != NULL) {


                if (depth > maxDepth) {


                    maxDepth = depth;


                }


                push(&stack, treeNode->left, depth + 1);


                push(&stack, treeNode->right, depth + 1);


            }


            free(node);


        }


    }


    return maxDepth;


}

2. 用队列计算树高

队列是一种先进先出的数据结构，可以用来进行广度优先遍历，从而计算树的高度。以下是用队列计算树高的实现：

#include <stdio.h>


#include <stdlib.h>


struct TreeNode {


    int data;


    struct TreeNode *left;


    struct TreeNode *right;


};


struct QueueNode {


    struct TreeNode *treeNode;


    struct QueueNode *next;


};


struct Queue {


    struct QueueNode *front;


    struct QueueNode *rear;


};


void enqueue(struct Queue *queue, struct TreeNode *treeNode) {


    struct QueueNode *newNode = (struct QueueNode *)malloc(sizeof(struct QueueNode));


    newNode->treeNode = treeNode;


    newNode->next = NULL;


    if (queue->rear == NULL) {


        queue->front = queue->rear = newNode;


    } else {


        queue->rear->next = newNode;


        queue->rear = newNode;


    }


}


struct TreeNode *dequeue(struct Queue *queue) {


    if (queue->front == NULL) return NULL;


    struct QueueNode *temp = queue->front;


    queue->front = queue->front->next;


    if (queue->front == NULL) {


        queue->rear = NULL;


    }


    struct TreeNode *treeNode = temp->treeNode;


    free(temp);


    return treeNode;


}


int height(struct TreeNode *root) {


    if (root == NULL) return 0;


    struct Queue queue = {NULL, NULL};


    enqueue(&queue, root);


    int height = 0;


    while (1) {


        int nodeCount = 0;


        struct QueueNode *temp = queue.front;


        while (temp != NULL) {


            nodeCount++;


            temp = temp->next;


        }


        if (nodeCount == 0) {


            return height;


        }


        height++;


        while (nodeCount > 0) {


            struct TreeNode *node = dequeue(&queue);


            if (node->left != NULL) {


                enqueue(&queue, node->left);


            }


            if (node->right != NULL) {


                enqueue(&queue, node->right);


            }


            nodeCount--;


        }


    }


}

三、广度优先遍历法计算树高

广度优先遍历法（BFS）也是一种常见的求树高的方法。其基本思想是：从根节点开始，逐层遍历树的每一层，直到遍历到最后一层。以下是广度优先遍历法计算树高的具体实现：

#include <stdio.h>


#include <stdlib.h>


struct TreeNode {


    int data;


    struct TreeNode *left;


    struct TreeNode *right;


};


struct QueueNode {


    struct TreeNode *treeNode;


    struct QueueNode *next;


};


struct Queue {


    struct QueueNode *front;


    struct QueueNode *rear;


};


void enqueue(struct Queue *queue, struct TreeNode *treeNode) {


    struct QueueNode *newNode = (struct QueueNode *)malloc(sizeof(struct QueueNode));


    newNode->treeNode = treeNode;


    newNode->next = NULL;


    if (queue->rear == NULL) {


        queue->front = queue->rear = newNode;


    } else {


        queue->rear->next = newNode;


        queue->rear = newNode;


    }


}


struct TreeNode *dequeue(struct Queue *queue) {


    if (queue->front == NULL) return NULL;


    struct QueueNode *temp = queue->front;


    queue->front = queue->front->next;


    if (queue->front == NULL) {


        queue->rear = NULL;


    }


    struct TreeNode *treeNode = temp->treeNode;


    free(temp);


    return treeNode;


}


int height(struct TreeNode *root) {


    if (root == NULL) return 0;


    struct Queue queue = {NULL, NULL};


    enqueue(&queue, root);


    int height = 0;


    while (1) {


        int nodeCount = 0;


        struct QueueNode *temp = queue.front;


        while (temp != NULL) {


            nodeCount++;


            temp = temp->next;


        }


        if (nodeCount == 0) {


            return height;


        }


        height++;


        while (nodeCount > 0) {


            struct TreeNode *node = dequeue(&queue);


            if (node->left != NULL) {


                enqueue(&queue, node->left);


            }


            if (node->right != NULL) {


                enqueue(&queue, node->right);


            }


            nodeCount--;


        }


    }


}

四、总结

综上所述，用C语言求树高的方法有递归法、非递归法、广度优先遍历法等。递归法直观且易于实现，但在深度较大的树中可能会导致栈溢出问题；非递归法利用栈或队列来模拟递归过程，避免了栈溢出问题，但实现较为复杂；广度优先遍历法逐层遍历树的每一层，适用于层次遍历树的情况。根据具体需求，可以选择合适的方法来求树高。

在实际的项目管理中，合理使用项目管理系统如研发项目管理系统PingCode和通用项目管理软件Worktile，可以有效提升开发效率和项目管理水平。这些系统提供了强大的任务管理、进度跟踪和团队协作功能，使得项目管理更加高效和便捷。

相关问答FAQs：

1. 如何使用C语言编写一个函数来计算树的高度？

  • 首先，你需要定义一个树的数据结构，可以使用指针来表示树的节点。
  • 其次，你可以使用递归的方式来计算树的高度。递归的思想是，树的高度等于左子树的高度和右子树的高度中的较大值加1。
  • 然后，你可以编写一个递归函数，该函数接受一个树的节点作为参数，并返回该节点为根的子树的高度。
  • 最后，你可以在主函数中调用该递归函数来计算整个树的高度。

2. 如何处理空树的情况？

  • 当树为空时，即根节点为NULL时，可以将树的高度定义为0。这是因为根节点为空的树被认为是一棵空树，其高度为0。

3. 如何处理只有一个节点的树的情况？

  • 当树只有一个节点时，其高度定义为1。这是因为树只有一个节点时，该节点就是树的根节点，且没有任何子节点。所以，树的高度为1。

原创文章，作者：Edit1，如若转载，请注明出处：https://docs.pingcode.com/baike/1021858

赞 (0)
Edit1Edit1
上一篇 2024年8月27日 下午12:50
下一篇 2024年8月27日 下午12:50
免费注册
电话联系

4008001024

微信咨询
微信咨询
返回顶部