数据结构(一)——树

二叉树：

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


typedef struct BIT_NODE {
    char data;
    struct BIT_NODE* lchild;
    struct BIT_NODE* rchild;
}BIT_NODE_t;

// 先序遍历
void pre_travel(BIT_NODE_t root)
{
    printf("%c
", root.data);

    if (root.lchild != NULL) {
        pre_travel(*root.lchild);
    }
    if (root.rchild != NULL) {
        pre_travel(*root.rchild);
    }

}

// 中序遍历
void mid_travel(BIT_NODE_t root)
{
    if (root.lchild != NULL) {
        mid_travel(*root.lchild);
    }
    printf("%c
", root.data);
    if (root.rchild != NULL) {
        mid_travel(*root.rchild);
    }
}

// 后序
void after_travel(BIT_NODE_t root) 
{
    if (root.lchild != NULL) {
        after_travel(*root.lchild);
    }
    if (root.rchild != NULL) {
        after_travel(*root.rchild);
    }
    printf("%c
", root.data);
}

int main()
{
    BIT_NODE_t NodeA, NodeB, NodeC, NodeD, NodeE, NodeF, NodeG;

    memset(&NodeA, 0, sizeof(BIT_NODE_t));
    memset(&NodeB, 0, sizeof(BIT_NODE_t));
    memset(&NodeC, 0, sizeof(BIT_NODE_t));
    memset(&NodeD, 0, sizeof(BIT_NODE_t));
    memset(&NodeE, 0, sizeof(BIT_NODE_t));
    memset(&NodeF, 0, sizeof(BIT_NODE_t));
    memset(&NodeG, 0, sizeof(BIT_NODE_t));

    NodeA.data = 'A';
    NodeA.lchild = &NodeB;
    NodeA.rchild = &NodeC;

    NodeB.data = 'B';
    NodeB.lchild = &NodeD;
    NodeB.rchild = &NodeE;

    NodeC.data = 'C';
    NodeC.lchild = &NodeF;
    NodeC.rchild = &NodeG;

    NodeD.data = 'D';
    NodeE.data = 'E';
    NodeF.data = 'F';
    NodeG.data = 'G';

    // 先序遍历
    //pre_travel(NodeA);

    // mmid
    //mid_travel(NodeA);

    // after
    after_travel(NodeA);

    system("pause");
    return 0;
}

叶子节点：没有左孩子也没有右孩子

　　　　　叶子节点的个数 = 左子树叶子节点个数 + 右子树叶子节点个数

// 求树的叶子节点数
void leaf_num(BIT_NODE_t root, int* num)
{

    if ( root.lchild == NULL && root.rchild == NULL ) {
        (*num)++;
    }
    if ( root.lchild != NULL ) {
        leaf_num(*root.lchild, num);
    }
    if (root.rchild != NULL) {
        leaf_num(*root.rchild, num);
    }

}

树的高度 ：

　　　　1.求根节点左子树的高度，再求根节点右子树的高度，比较子树的最大高度再加 1；

　　　　2.若左子树还是树，重复步骤1；若右子树还是树，重复步骤1

// 求树的高度
int tree_depth(BIT_NODE_t root)
{
    int left = 0;
    int right = 0;
    if (root.lchild != NULL) {
        left = tree_depth(*root.lchild);
    }
    if (root.rchild != NULL) {
        right = tree_depth(*root.rchild);
    }
    int max = left > right ? left : right;
    return max + 1;
}

拷贝二叉树

　　

// 拷贝二叉树 返回新二叉树的根节点
BIT_NODE_t* copy_tree(BIT_NODE_t *root)
{
    if (root == NULL) {
        return NULL;
    }
    BIT_NODE_t* left = copy_tree(root->lchild);
    BIT_NODE_t* right = copy_tree(root->rchild);

    BIT_NODE_t* new_node = (BIT_NODE_t*)malloc(sizeof(BIT_NODE_t));
    new_node->data = root->data;
    new_node->lchild = left;
    new_node->rchild = right;

    return new_node;
}

树的非递归遍历 (中序遍历)

　　

创建树：

　　　　1.根据先序和中序可以创建树

　　　　2.井号法创建树（先序遍历的方式）