二叉树的常见操作实现

二叉树的常见操作实现：

• 先序遍历、中序遍历、后序遍历层序遍历
• 由先序序列和中序序列建立二叉树
• 由后序序列和中序序列建立二叉树
• 由层序序列和中序序列建立二叉树
• 求二叉树的叶子结点数
• 求二叉树的高度
• 查找值为x的结点
• 输出二叉树中值为x的节点的所有祖先
• 输出值为x的结点的所有子孙结点
• 求二叉树中结点值x的层数
• 求二叉树第k层的结点个数
• 求第k层上叶子结点的个数
• 反转二叉树 将左边的二叉树反转成右边的二叉树

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
struct node
{
    char data;
    struct node *lt, *rt;
};

// 前序遍历
void tree_preorder(struct node *root)
{
    if(root)
    {
        printf("%c", root->data);       
        tree_preorder(root->lt);
        tree_preorder(root->rt);
    }
}

// 中序遍历
void tree_midorder(struct node *root)
{
    if(root)
    {
        tree_midorder(root->lt);
        printf("%c", root->data);          
        tree_midorder(root->rt);
    }
}

// 后序遍历
void tree_postorder(struct node *root)
{
    if(root)
    {
        tree_postorder(root->lt);
        tree_postorder(root->rt);
        printf("%c", root->data);
    }
}

// 层序遍历
void tree_levelorder( struct node *root )
{
    struct node *queue[100];
    struct node *pt;
    int head;
    int tail;

    head = 0;
    tail = 0;

    queue[tail++] = root;
    while( tail != head )
    {
        pt = queue[head++];
        printf("%c", pt->data);
        if( pt->lt != NULL )
        {
            queue[tail++] = pt->lt;
        }

        if( pt->rt != NULL )
        {
            queue[tail++] = pt->rt;
        }
    }
}

// 由先序序列和中序序列建立二叉树
struct node *create_by_pre_and_mid(int n, char *pre, char *mid)
{
    struct node *root;
    int i;

    if(n==0)
        return NULL;

    root=(struct node *)malloc(sizeof(struct node));
    root->data=pre[0];

    for(i=0;i<n;i++) // 寻找左右子树的元素
        if(pre[0]==mid[i])
            break;

    root->lt = create_by_pre_and_mid(i, pre+1, mid); // 建立左子树
    root->rt = create_by_pre_and_mid(n-i-1, pre+i+1, mid+i+1); // 建立右子树

    return root;
}

// 由后序序列和中序序列建立二叉树
struct node *create_by_post_and_mid(int n, char *post, char *mid)
{
    struct node *root;
    int i;

    if(n==0)
        return NULL;

    root=(struct node *)malloc(sizeof(struct node));
    root->data=post[n-1];

    for(i=0;i<n;i++) // 寻找左右子树的元素
        if(post[n-1]==mid[i])
            break;

    root->lt = create_by_post_and_mid(i, post, mid); // 建立左子树
    root->rt = create_by_post_and_mid(n-i-1, post+i, mid+i+1); // 建立右子树

    return root;
}

// 由层序序列和中序序列建立二叉树
struct node *create_by_level_and_mid(int n, char *level, char *mid)
{
    struct node *root;
    char left[30];
    char right[30];
    int i, k;
    int l, r;
    int lcnt, rcnt;

    lcnt = 0;
    rcnt = 0;

    if( n == 0 )
        return NULL;

    root = (struct node *)malloc(sizeof(struct node));
    root->data = level[0];

    // 找到根节点
    for( i = 0; i < n; i++ )
        if( level[0] == mid[i] )
            break;
    
    // 划分左右子树的层序序列
    for( k = 0; k < n; k++ )
    {
        for( l = 0; l < i; l++ )
        {
            if( mid[l] == level[k] )
            {

                left[lcnt++] = level[k];
            }
        }
        for( r = 0; r < n-i-1; r++ )
        {
            if( mid[r+i+1] == level[k] )
            {
                right[rcnt++] = level[k];
            }
        }
    }

    root->lt = create_by_level_and_mid( lcnt, left, mid );
    root->rt = create_by_level_and_mid( rcnt, right, mid+i+1 );

    return root;
}

// 求二叉树的叶子结点数
int tree_leaves( struct node *root )
{
    if( root == NULL )
    {
        return 0;
    }
    else if( root->lt == NULL && root->rt == NULL )
    {
        return 1;
    }
    else
    {
        return ( tree_leaves(root->lt) + tree_leaves(root->rt) );
    }
}

// 求二叉树的高度
int tree_height( struct node *root )
{
    int lh, rh, max;

    if( root == NULL )
    {
        return 0;
    }
    
    lh = tree_height( root->lt );
    rh = tree_height( root->rt );

    max = ( lh > rh ) ? lh : rh;

    return ( max + 1 );
}

// 查找值为x的结点
struct node *tree_find_x( struct node *root, char x )
{
    struct node *tmp;

    if( root == NULL )
        return NULL;

    if( root->data == x )
        return root;

    tmp = tree_find_x( root->lt, x ); // 查找左子树
    if( tmp != NULL )
        return tmp;

    return tree_find_x( root->rt, x ); // 查找右子树
}

// 输出二叉树中值为x的节点的所有祖先
int tree_ancestor( struct node *root, char x )
{
    if( root == NULL )
    {
        return 0;
    }
    else if( (root->lt != NULL && root->lt->data == x) || (root->rt != NULL && root->rt->data == x) )
    {
        // 父结点
        printf("%c ", root->data);
        return 1;
    }
    else if( tree_ancestor( root->lt, x ) || tree_ancestor( root->rt, x ) )
    {
        // 祖先结点
        printf("%c ", root->data);
        return 1;
    }
    else
    {
        return 0;
    }
}

// 输出二叉树中值为x的节点的所有祖先
// https://blog.csdn.net/u010095372/article/details/83443750
int tree_root_of_x( struct node *root, char x )
{
    if( root == NULL )
        return 0;

    if( root->data == x )
        return 1;

    if( root )
    {
        if( tree_root_of_x( root->lt, x ) || tree_root_of_x( root->rt, x ) )
        {
            printf("%c ", root->data);
            return 1;
        }
    }

    return 0;
}

// 输出值为x的结点的所有子孙结点
void tree_child_of_x( struct node *root, char x )
{
    struct node *tmp;

    tmp = tree_find_x( root, x );
    if( tmp != NULL )
    {
        tree_preorder( tmp->lt );
        tree_preorder( tmp->rt );
    }
}

// 输出值为x的结点的所有子孙结点
void tree_child_x( struct node *root, char x )
{
    if( root != NULL )
    {
        if( root->data == x )
        {
            tree_preorder( root->lt );
            tree_preorder( root->rt );        
        }
        else
        {
            tree_child_x( root->lt, x );
            tree_child_x( root->rt, x );
        }
    }
}

// 求二叉树中结点值x的层数
// 返回0表示未找到，根节点的层数为1，h初始置为1
int tree_find_x_level( struct node *root, char x, int h )
{
    int level;

    if( root == NULL )
        return 0;
    
    if( root->data == x )
        return h;

    level = tree_find_x_level( root->lt, x, h+1 );
    if( level != 0 )
        return level;

    return tree_find_x_level( root->rt, x, h+1 );
}

// 求二叉树第k层的结点个数
int tree_cnt_of_level_k( struct node *root, int h, int k )
{
    if( root == NULL )
    {
        return 0;
    }
    else
    {
        if( h == k )
        {
            return 1;
        }

        if( h < k )
        {
            return ( tree_cnt_of_level_k( root->lt, h+1, k ) + tree_cnt_of_level_k( root->rt, h+1, k ) );
        }
    }
    return 0;
}

// 求第k层上叶子结点的个数
int tree_leaves_of_level_k( struct node *root, int h, int k )
{
    if( root == NULL )
    {
        return 0;
    }
    else
    {
        if( h == k && root->lt == NULL && root->rt == NULL )
        {
            return 1;
        }

        if( h < k )
        {
            return ( tree_leaves_of_level_k( root->lt, h+1, k ) + tree_leaves_of_level_k( root->rt, h+1, k ) );
        }
    }
    // ( h==k 但是存在左子树或存在右子树 )
    return 0;
}

// 反转二叉树 将左边的二叉树反转成右边的二叉树
void tree_invert( struct node *root )
{
    struct node *tmp;

    if( root )
    {
        tmp = root->lt;
        root->lt = root->rt;
        root->rt = tmp;

        tree_invert( root->lt );
        tree_invert( root->rt );
    }
}

/**
 *
 *           A
 *          / 
 *         B   C
 *        /  /  
 *       D  E G  H
 *         /      
 *        F        I
 *
 *    char *post = "DFEBGIHCA";
 *    char *pre = "ABDEFCGHI";
 *    char *mid = "DBFEAGCHI";
 *    char *level = "ABCDEGHFI";
 *
 *
 *           A
 *          / 
 *         B   C
 *        /  /  
 *       D  E G  H
 *         /      
 *        F        I
 *                / 
 *               J   K
 *                    
 *                     L
 *
 *  char *mid = "DBFEAGCHJIKL"
 *  char *level = "ABCDEGHFIJKL"
 **/
int main( void )
{
    struct node *tmp;
    struct node *root=NULL;
    int len;
    //char *post = "DFEBGIHCA";
    //char *pre = "ABDEFCGHI";
    //char *mid = "DBFEAGCHI";
    //char *level = "ABCDEGHFI";

    char *mid = "DBFEAGCHJIKL";
    char *level = "ABCDEGHFIJKL";

    int leaves;
    int height;
    int level_of_x;
    int x;
    int cnt_of_level;
    int leaves_of_level;
    int k;

    len = strlen(mid);

    //root = create_by_pre_and_mid(len, pre, mid);
    //root = create_by_post_and_mid(len, post, mid);
    root = create_by_level_and_mid( len, level, mid );

    printf("tree_preorder: ");
    tree_preorder(root);
    printf("
");

    printf("tree_midorder: ");
    tree_midorder(root);
    printf("
");

    printf("tree_postorder: ");
    tree_postorder(root);
    printf("
");

    printf("tree_levelorder: ");
    tree_levelorder( root );
    printf("
");


    leaves = tree_leaves( root );
    printf("tree_leaves: %d
", leaves);

    height = tree_height( root );
    printf("tree_height: %d
", height);


    for( k = 1; k <= height; k++ )
    {
        cnt_of_level = tree_cnt_of_level_k( root, 1, k );
        printf("tree_cnt_of_level_k(%d): %d
", k, cnt_of_level);
    }

    for( k = 1; k <= height; k++ )
    {
        leaves_of_level = tree_leaves_of_level_k( root, 1, k );
        printf("tree_leaves_of_level_k(%d): %d
", k, leaves_of_level);
    }

    for( x = 0; x < 12; x++ )
    {
        printf("tree_ancestor(%c):", 'A'+x);
        tree_ancestor( root, 'A'+x );
        printf("
");
    }

    for( x = 0; x < 12; x++ )
    {
        printf("tree_root_of_x(%c):", 'A'+x);
        tree_root_of_x( root, 'A'+x );
        printf("
");
    }

    for( x = 0; x < 12; x++ )
    {
        printf("tree_child_of_x(%c):", 'A'+x);    
        tree_child_of_x( root, 'A'+x);        
        printf("
");
    }

    for( x = 0; x < 12; x++ )
    {
        printf("tree_child_x(%c):", 'A'+x);    
        tree_child_x( root, 'A'+x);        
        printf("
");
    }    

    for( x = 0; x < 12; x++ )
    {
        tmp = tree_find_x( root, 'A'+x );
        if( tmp )
        {
            printf("tree_find_x(%c): %p, %c
", 'A'+x, tmp, tmp->data);
        }
        else
        {
            printf("tree_find_x( %c ) not found!
", 'A'+x);
        }
    }

    for( x = 0; x < 12; x++ )
    {
        level_of_x = tree_find_x_level( root, 'A'+x, 1 );
        printf("tree_find_x_level(%c): %d
", 'A'+x, level_of_x );
    }


    printf("==============================
");
    tree_invert( root );
    printf("after tree_invert
");

    printf("tree_preorder: ");
    tree_preorder(root);
    printf("
");

    printf("tree_midorder: ");
    tree_midorder(root);
    printf("
");

    printf("tree_postorder: ");
    tree_postorder(root);
    printf("
");

    printf("tree_levelorder: ");
    tree_levelorder( root );
    printf("
");


    system("pause");
    return 0;
}

---

参考：

https://www.cnblogs.com/lfri/p/10256069.html

https://blog.csdn.net/u010095372/article/details/83443750