数据结构—二叉树（数据类型int）

#pragma once
#include<malloc.h>
#include<assert.h>
typedef int BTDataType;
typedef struct BinaryTreeNode
{
    struct BinaryTreeNode* _left;
    struct BinaryTreeNode* _right;
    BTDataType _data;
}BTNode;

#include "Queue.h"
#include"Stack.h"

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);//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* root = NULL;
    root = (BTNode*)malloc(sizeof(BTNode));
    assert(root);
    root->_data = x;
    root->_left = NULL;
    root->_right = NULL;
    return root;
}

BTNode* CreateBTree(BTDataType* a, size_t* pIndex, BTDataType invalid)
{
    assert(a);
    BTNode* tree = NULL;
    if (a[*pIndex] != invalid)
    {
        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)
{
    static size_t TreeSize = 0;
    if (root == NULL)
    {
        return 0;
    }
    TreeSize++;
    BTreeSize(root->_left);
    BTreeSize(root->_right);
    return TreeSize;
}

size_t BTreeLeafSize(BTNode* root)
{

    static size_t LeafSize = 0;
    if (root == NULL)
    {
        return 0;
    }
    if (root->_left == NULL && root->_right == NULL)
    {
        LeafSize++;
    }
    BTreeLeafSize(root->_left);
    BTreeLeafSize(root->_right);
    return LeafSize;
}

size_t BTreeKLevelSize(BTNode* root, size_t k)
{
    static size_t KLeafSize = 0;
    if (root == NULL)
    {
        return 0;
    }   

    if (k == 1 && root)
    {
        KLeafSize++;
    }
    BTreeKLevelSize(root->_left, k - 1);
    BTreeKLevelSize(root->_right, k - 1);
    return KLeafSize;
}

size_t BTreeDepth(BTNode* root)
{
    if (root == NULL)
    {
        return 0;
    }
    size_t leftdeep = BTreeDepth(root->_left);
    size_t rightdeep = BTreeDepth(root->_right);
    return leftdeep > rightdeep ? (leftdeep + 1) : (rightdeep + 1);
}

BTNode* BTreeFind(BTNode* root, BTDataType x)
{

    if (root == NULL)
    {
        return NULL;
    }   
    static BTNode* renode = NULL;
    if (root->_data == x)
    {
        renode = root;
    }
    BTreeFind(root->_left, x);
    BTreeFind(root->_right, x);
    return renode;
}

void BTreeLevelOrder(BTNode* root)
{   
    assert(root);
    Queue q;
    QueueInit(&q);
    QueuePush(&q, root);
    while (QueueEmpty(&q))
    {       
        BTNode* tmp = QueueFront(&q);
        if (tmp->_left)
        {
            QueuePush(&q, tmp->_left);
        }
        if (tmp->_right)
        {
            QueuePush(&q, tmp->_right);
        }
        printf("%d", tmp->_data);
        QueuePop(&q);
    }
}

int IsCompleteBTree1(BTNode* root)
{
    assert(root);
    int flag = 1;
    Queue q;
    QueueInit(&q);
    QueuePush(&q, root);
    while (QueueEmpty(&q))
    {
        BTNode* tmp = QueueFront(&q);
        QueuePop(&q);
        if (tmp->_left)
        {
            if (flag == 0)
            {
                return 0;
            }
            QueuePush(&q, tmp->_left);
        }
        else
        {
            flag = 0;
        }
        if (tmp->_right)
        {
            if (flag == 0)
            {
                return 0;
            }
            QueuePush(&q, tmp->_right);
        }
        else
        {
            flag = 0;
        }
    }
    return 1;
}

int IsCompleteBTree(BTNode* root)
{
    assert(root);
    Queue q;
    QueueInit(&q);
    QueuePush(&q, root);
    while (QueueEmpty(&q))
    {
        BTNode* tmp = QueueFront(&q);
        if (tmp)
        {
                QueuePush(&q, tmp->_left);

                QueuePush(&q, tmp->_right);
            QueuePop(&q);
        }
        else
        {
            while (QueueEmpty(&q))
            {
                BTNode* tmp1 = QueueFront(&q);
                if (tmp1 != NULL)
                {
                    return 0;
                }
                QueuePop(&q);
            }
            return 1;
        }
    }
}

void BTreePrevOrderNonR(BTNode* root)
{
    static s;
    StackInit(&s, 10);
    BTNode* cur = root;
    BTNode* tmp = NULL;

    while (cur || StackEmpty(&s))
    {
        while (cur)
        {
            printf("%d ", cur->_data);
            StackPush(&s, cur);
            cur = cur->_left;
        }
        tmp = StackTop(&s);
        cur = tmp->_right;      

        StackPop(&s);
    }
}

void BTreeInOrderNonR(BTNode* root)
{
    static s;
    BTNode* cur = root;
    BTNode* tmp = NULL;
    StackInit(&s, 10);
    while (cur || StackEmpty(&s))
    {
        while (cur)
        {
            StackPush(&s, cur);
            cur = cur->_left;
        }
        tmp = StackTop(&s);
        printf("%d ", tmp->_data);
        cur = tmp->_right;

        StackPop(&s);
    }
}

void BTreePostOrderNonR(BTNode* root)
{
    static s;
    BTNode* cur = root;
    BTNode* tmp = NULL;
    BTNode* tmp1 = NULL;
    StackInit(&s, 10);
    while (cur || StackEmpty(&s))
    {
        while (cur)
        {
            StackPush(&s, cur);
            cur = cur->_left;
        }
        tmp = StackTop(&s);
        if (tmp->_right == NULL || tmp->_right== tmp1)
        { 
            printf("%d ", tmp->_data);
            tmp1 = tmp;
            StackPop(&s);
        }
        else
        {
            cur = tmp->_right;
        }
    }
}