数据结构---二叉树的实现1（递归方式）

建二叉树

//BT.h
#pragma once 

typedef int BTDataType;

typedef struct BinaryTreeNode
{
    struct BinaryTreeNode* _left;
    struct BinaryTreeNode* _right;
    BTDataType _data;
}BTNode;
BTNode* BuyBTNode(BTDataType x);
// 创建二叉树 
BTNode* CreateBTree(BTDataType* a, size_t* pIndex, BTDataType invalid);
void BTreePrevOrder(BTNode* root);
void BTreeInOrder(BTNode* root);
void BTreePostOrder(BTNode* root);

size_t BTreeSize(BTNode* root);
size_t BTreeLeafSize(BTNode* root);
size_t BTreeKLevelSize(BTNode* root, size_t k);
size_t BTreeDepth(BTNode* root);
BTNode* BTreeFind(BTNode* root, BTDataType x);
void BTreeLevelOrder(BTNode* root);
// 判断完全二叉树 
int IsCompleteBTree(BTNode* root);
int IsCompleteBTree1(BTNode* root);// flag的方式判断 
// 非递归遍历 
void BTreePrevOrderNonR(BTNode* root);
void BTreeInOrderNonR(BTNode* root);
void BTreePostOrderNonR(BTNode* root);


BTNode* BuyBTNode(BTDataType x)
{
    BTNode* node = (BTNode*)malloc(sizeof(BTNode));
    assert(node);

    node->_data = x;
    node->_left = NULL;
    node->_right = NULL;
    return node;
}
BTNode* CreateBTree(BTDataType* a, size_t* pIndex, BTDataType invalid)
{
    assert(a);

    BTNode*tree=NULL;
    if (a[*pIndex] == invalid)
        tree=NULL;
    else
    {
        tree = BuyBTNode(a[*pIndex]);
        (*pIndex)++;
        tree->_left = CreateBTree(a, pIndex, invalid);

        (*pIndex)++;
        tree->_right = CreateBTree(a, pIndex, invalid);
    }
    return tree;
}
void BTreePrevOrder(BTNode* root)
{
    if (root == NULL)
        return;

    printf("%d ", root->_data);
    BTreePrevOrder(root->_left);
    BTreePrevOrder(root->_right);
}
void BTreeInOrder(BTNode* root)
{
    if (root == NULL)
        return;

    BTreeInOrder(root->_left);
    printf("%d ", root->_data);
    BTreeInOrder(root->_right);
}
void BTreePostOrder(BTNode* root)
{
    if (root == NULL)
        return;

    BTreePostOrder(root->_left);
    BTreePostOrder(root->_right);
    printf("%d ", root->_data);
}

size_t BTreeSize(BTNode* root)
{
    if (root == NULL)
        return 0;
    else
        return 1+BTreeSize(root->_left) + BTreeSize(root->_right);
}
size_t BTreeLeafSize(BTNode* root)
{
    if (root == NULL)
        return 0;
    else if (root->_left == NULL&&root->_right == NULL)
        return 1;
    else
        return BTreeLeafSize(root->_left) + BTreeLeafSize(root->_right);
}
size_t BTreeKLevelSize(BTNode* root, size_t k)
{
    if (root == NULL)
        return 0;
    else if (k == 1)
        return 1;
    else
        return BTreeKLevelSize(root->_left, k - 1) + BTreeKLevelSize(root->_right, k - 1);
}
size_t BTreeDepth(BTNode* root)
{
    size_t depthleft = 0, depthright = 0;
    if (root == NULL)
        return 0;
    depthleft = BTreeDepth(root->_left);
    depthright = BTreeDepth(root->_right);
        return depthleft > depthright ?  (1+depthleft):(1+depthright);
}

BTNode* BTreeFind(BTNode* root, BTDataType x)
{
    BTNode*key = NULL;
    if (root == NULL)
        return NULL;

    if (root->_data == x)
        key=root;
    else
    {
        key = BTreeFind(root->_left, x);
        if (key==NULL)
            key = BTreeFind(root->_right, x);
    }
    return key;
}

#include"BT.h"

void TestBinaryTree()
{
    int a[] = { 1, 2, 3, '#', '#', 4, '#', '#', 5, 6, '#', '#', '#' };
    size_t index = 0;
    BTNode* tree = CreateBTree(a, &index, '#');
    BTreePrevOrder(tree);
    printf("\n");
    BTreeInOrder(tree);
    printf("\n");
    BTreePostOrder(tree);
    printf("\n");

    printf("BTreeSize?%d\n", BTreeSize(tree));
    printf("BTreeLeafSize?%d\n", BTreeLeafSize(tree));
    printf("BTreeKLevelSize?%d\n", BTreeKLevelSize(tree, 2));
    printf("BTreeDepth?%d\n", BTreeDepth(tree));
    printf("%d\n", BTreeFind(tree, 4)->_data);
}
int main()
{
    TestBinaryTree();
    system("pause");
    return 0;
}