二叉树的几种创建方法

 #返回上一级

@Author: 张海拔

@Update: 2014-01-28

@Link: http://www.cnblogs.com/zhanghaiba/p/3535769.html

二叉树这种数据结构非常经典。研究二叉树之前必须得创建二叉树，这里简单介绍三种常见的创建二叉树的方式——

             89
         ____|____
         |       |
         73      82
        _|__  ___|___
        |  |  |     |
              92    5
             _|__  _|__
             |  |  |  |
             69
            _|__
            |  |

（1）随机创建一棵二叉树

比如我们要随机生成含n个节点的二叉树，默认指定节点值的范围是[0, 100)

那么生成一个节点后，设随机生成的左子树包括节点数是left_n = random[0, n-1]，则right_n = (n-1) - left_n

这样递归下去，当n<=0返回空，n==1返回一个根节点

该算法生成的二叉树是比较“平衡”的（期望情况下左子树和右子树数目差不多），原因是生成深度很浅时比深度很深时范围大，相对不容易取到边界值。

如上所示的二叉树，创建过程中，打印left_n和right_n结果会是：

left_n=1 right_n = 4

left_n=2 right_n = 1

left_n=1 right_n = 0

（2）根据二叉树的前序、中序或后序序列（同时包含空节点的序列）来创建

如上所示的二叉树，包括空节点的前序序列表示为：89 73 # # 82 92 69 # # # 5 # #（空节点标记为#）

中序、后序同理

（3）根据二叉树对应的“完全二叉树”序列来创建（设下标从0开始）

想象如上所示的二叉树嵌入到完全二叉树中，则从下标0~15，完全二叉树对应的序列是：

89 73 82 # # 92 5 # # # # 69 # # #

把序列存入数组order[]中，若设树的根节点值为order[idx]，则其左子树根节点的值为order[idx*2 +1]，右子树的为order[idx*2 +2]

（4）由遍历序列创建二叉树 link(public)，这个已经单独介绍过了，包括给定中序前序创建和给定中序后序创建两种情况。

不过这种创建方式创建出来的二叉树有局限性：要求每个节点的“值”是不同的。

假如有两个节点“值”相同，比如完全二叉树的{1，1}和{1, #, 1}，可以创建两棵不同的树，但它们的前序中序序列是完全一样的。

/*
 *Author: ZhangHaiba
 *Date: 2014-1-28
 *File: binary_tree.c
 *
 *a demo shows three ways to create binary tree
 */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MOD 100
#define LEN 1024
#define CMD_LEN 128

typedef struct node* link;
typedef struct node {
    int item;
    link left;
    link right;
}node;

//public
link NODE(int item, link left, link right);
link bt_create_by_random(int n);
link bt_create_by_preorder(void);
//idx begin with 0
link bt_create_by_complete_bt_order(int *order, int order_len, int idx);
link bt_preorder(link root);
void bt_show_by_tree(link root);

//private
link bt_create_by_random_core(int n);
void tree_print(link root, FILE *fd);


int main(void)
{
    char cmd[CMD_LEN];
    int n, i, order[LEN];

    printf("there is three ways to create binary tree, including:
");
    printf("[r] create binary tree by random
");
    printf("[p] create binary tree by preorder(NULL node values -1)
");
    printf("[c] create binary tree by complete binary tree order(NULL node values -1)
");
    printf("[q] quit
");
    printf("please choice: enter charactor 'r' 'p' or 'c', or 'q' to quit
");
    while(1) {
        scanf("%s", cmd);
        switch(cmd[0]) {
            case 'r':
            printf("create binary tree with n nodes by randmon, please assgin n:
");
            scanf("%d", &n);
            link bt_tree_a = bt_create_by_random(n);
            bt_show_by_tree(bt_tree_a);
            break;
            case 'p':
            printf("please input preorder(NULL node values -1)
");
            link bt_tree_b = bt_create_by_preorder();
            bt_show_by_tree(bt_tree_b);        
            break;
            case 'c':
            printf("to create complete binary tree order, assgin its length as:
");
            scanf("%d", &n);
            printf("please input complete binary tree order(NULL node values -1)
");
            for (i = 0; i < n; ++i)
                scanf("%d", order+i);
            link bt_tree_c = bt_create_by_complete_bt_order(order, n, 0);
            bt_show_by_tree(bt_tree_c);
            break;
            case 'q':
            return 0;
            default:
            break;
        }
    }
    return 0;
}

link NODE(int item, link left, link right)
{
    link born = malloc( sizeof (node) );
    born->item = item;
    born->left = left;
    born->right = right;
    return born;
}

link bt_create_by_random(int n)
{
    srand( (unsigned)time(NULL) );
    return bt_create_by_random_core(n);
}

link bt_create_by_random_core(int n)
{
    if (n <= 0)
        return NULL;
    if (n == 1)
        return NODE(rand()%MOD, NULL, NULL);

    link root = NODE(rand()%MOD, NULL, NULL);
    int left_n = rand()%(n-1) + 1, right_n = (n-1) - left_n;
    root->left = bt_create_by_random_core(left_n);
    root->right = bt_create_by_random_core(right_n);
    return root;
}

link bt_create_by_preorder(void)
{
    int item;

    scanf("%d", &item);
    if (item == -1) //current root is NULL
        return NULL;
    link root = NODE(item, NULL, NULL);
    root->left = bt_create_by_preorder();
    root->right = bt_create_by_preorder();
    return root;
}


link bt_create_by_complete_bt_order(int *order, int n, int idx)
{
    if (order[idx] == -1 || idx >= n)
        return NULL;
    link root = NODE(order[idx], NULL, NULL);
    root->left = bt_create_by_complete_bt_order(order, n, idx*2+1);
    root->right = bt_create_by_complete_bt_order(order, n, idx*2+2);
    return root;
}

void bt_show_by_tree(link root)
{
    char cmd[CMD_LEN];

    sprintf(cmd, "rm -f ./tree_src.txt");
    system(cmd);

    FILE *fd = fopen("./tree_src.txt", "a+");
    fprintf(fd, "
	\tree");
    tree_print(root, fd);
    fprintf(fd, "

");
    fclose(fd);

    sprintf(cmd, "cat ./tree_src.txt | ~/tree/tree");
    system(cmd);
}

void tree_print(link root, FILE *fd)
{    
    fprintf(fd, "(");
    if (root != NULL) {
        fprintf(fd, "%d", root->item);
        tree_print(root->left, fd);
        tree_print(root->right, fd);
    }
    fprintf(fd, ")");
}

 

测试示范：

ZhangHaiba-MacBook-Pro:code apple$ ./a.out
there is 3 way to create binary tree, including:
[r] create binary tree by random
[p] create binary tree by preorder(NULL node values -1)
[c] create binary tree by complete binary tree order(NULL node values -1)
[q] quit
please choice: enter charactor 'r' 'p' or 'c', or 'q' to quit
r
create binary tree with n nodes by randmon, please assgin n:
4

             19
          ___|___
          |     |
          61    49
         _|__  _|__
         |  |  |  |
         67
        _|__
        |  |

r
create binary tree with n nodes by randmon, please assgin n:
10

                  33
                 _|__
                 |  |
                 60
             ____|_____
             |        |
             80       6
            _|__   ___|___
            |  |   |     |
            43     93    54
         ___|___  _|__  _|__
         |     |  |  |  |  |
         67    31       40
        _|__  _|__     _|__
        |  |  |  |     |  |

r
create binary tree with n nodes by randmon, please assgin n:
10

             61
         ____|_____
         |        |
         11       89
        _|__   ___|___
        |  |   |     |
               34    58
              _|__  _|__
              |  |  |  |
              50
           ___|___
           |     |
           79    58
          _|__  _|__
          |  |  |  |
          81
         _|__
         |  |
         22
        _|__
        |  |

r   
create binary tree with n nodes by randmon, please assgin n:
10

                38
            ____|_____
            |        |
            38       8
           _|__  ____|____
           |  |  |       |
           54    14      62
          _|__  _|__  ___|___
          |  |  |  |  |     |
          3           68    9
         _|__        _|__  _|__
         |  |        |  |  |  |
         42
        _|__
        |  |

p
please input preorder(NULL node values -1)
89 73 -1 -1 82 92 69 -1 -1 -1 5 -1 -1

             89
         ____|____
         |       |
         73      82
        _|__  ___|___
        |  |  |     |
              92    5
             _|__  _|__
             |  |  |  |
             69
            _|__
            |  |

c
to create complete binary tree order, assgin its length as:
15
please input complete binary tree order(NULL node values -1)
89 73 82 -1 -1 92 5 -1 -1 -1 -1 69 -1 -1 -1

             89
         ____|____
         |       |
         73      82
        _|__  ___|___
        |  |  |     |
              92    5
             _|__  _|__
             |  |  |  |
             69
            _|__
            |  |

q

 #返回上一级