求树的高度的递归和非递归方法

我觉得树的知识大家也不陌生,这里直接上代码得了.

非递归的方法是采用了中序遍历的非递归方式:

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

#define   MAX   100

#define   ARRAY_SIZE(array, type)   (sizeof(array) / sizeof(type))

typedef struct node {
    int  value;
    struct node* left;
    struct node* right;
    struct node* parent;
} node;

typedef struct t_node {
    node*  p;
    int    height;
} t_node;

void insert_node(node** root, int value) {
    node* p = (node*)malloc(sizeof(node));
    if (NULL == p) {
        fprintf(stderr, "malloc memory failed!
");
        exit(1);
    }
    p->value = value;
    p->left = p->right = p->parent = NULL;
    
    if (NULL == *root) {
        *root = p;
    }
    else {
        node* q = *root;
        node* r = NULL;

        while (q != NULL) {
            r = q;
            if (q->value > p->value) {
                q = q->left;
            }
            else if (q->value < p->value) {
                q = q->right;
            }
            else {
                return;
            }
       }

        p->parent = r;

        if (r->value > p->value) {
            r->left = p;
        }
        else {
            r->right = p;
        }
    }
}

void pre_order(node* root) {
    if (root != NULL) {
        fprintf(stderr, "%d
", root->value);
        pre_order(root->left);
        pre_order(root->right);
    }
}

int  get_height(node* root) {
    t_node  stack[MAX];
    int     pos = -1;
    int     cur = 0;
    int     max = 0;

    while (root != NULL || pos != -1) {
        if (root == NULL) {
            root = stack[pos].p;
            cur = stack[pos].height;
            --pos;
            root = root->right;
        }
        else {
            ++pos;
            ++cur;
            stack[pos].p = root;
            stack[pos].height = cur;
            root = root->left;
        }

        if (cur > max) {
            max = cur;
        }
    }

    return  max;
}

int  main(void) {
    int  array[] = {5, 8, 3, 10, 2, 1, 0, 32, 321, 222, 11};
    int i = 0;
    node* root = NULL;

    for (; i < ARRAY_SIZE(array, int); ++i) {
        insert_node(&root, array[i]);
    }

    int height = get_height(root);

    fprintf(stderr, "%d
", height);


    return  0;
}

递归方法采用的是前序遍历的递归方式:

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

#define  ARRAY_SIZE(array, type)    (sizeof(array) / sizeof(type))

typedef struct node {
    int  value;
    struct node* left;
    struct node* right;
    struct node* parent;
} node;

void  insert_node(node** root, int value) {
    node* p = (node*)malloc(sizeof(node));
    if (NULL == p) {
        fprintf(stderr, "malloc memory failed!
");
        exit(1);
    }
    p->value = value;
    p->left = p->right = p->parent = NULL;

    if (*root == NULL) {
        *root = p;
    }
    else {
        node* q = *root;
        node* r = NULL;
        while (q != NULL) {
            r = q;
            if (q->value > p->value) {
                q = q->left;
            }
            else if (q->value < p->value) {
                q = q->right;
            }
            else {
                return;
            }
        }

        p->parent = r;
        if (r->value > p->value) {
            r->left = p;
        }
        else {
            r->right = p;
        }
    }
}

void pre_order(node* root) {
    if (root != NULL) {
        fprintf(stderr, "%d
", root->value);
        pre_order(root->left);
        pre_order(root->right);
    }
}

void get_height(node* root, int now, int* max) {
    if (root != NULL) {
        ++now;
        if (now > *max) {
            *max = now;
        }

        get_height(root->left, now, max);
        get_height(root->right, now, max);
    }
}

int  main(void) {
   int  array[] = {5, 3, 4, 1, 2, 0, -1, -2,  9, 21, 7, 6, 5, 22, 23, 24, 25};

   node*  root = NULL;
   int i = 0;
   for (; i < ARRAY_SIZE(array, int); ++i) {
       insert_node(&root, array[i]);
   }

   pre_order(root);

   int  max = 0;
   int  now = 0;

   get_height(root, now, &max);

   fprintf(stderr, "%d
", max);

   return  0;
}