二叉树（1）

---

/******************* "BinTree.h" ***********************/
#pragma once


typedef char BTDataType;

typedef struct BinTreeBTNode{
    struct BinTreeBTNode* _pLeft;
    struct BinTreeBTNode* _pRight;
    BTDataType data;
}BTNode, *PBTNode;


void _CreateBinTree(PBTNode* pRoot, BTDataType* array, int size, int* index, BTDataType invaild);
PBTNode BuyBinTreeBTNode(BTDataType data);
void CreateBinTree(PBTNode* pRoot, BTDataType* array, int size, BTDataType invalid);
PBTNode CopyBinTree(PBTNode pRoot);
void DestroyTree(PBTNode* pRoot);

void PreOrder(PBTNode pRoot/*,函数指针(操作)*/);
void W_PreOrder(PBTNode pRoot);

void InOrder(PBTNode pRoot);
void W_InOrder(PBTNode pRoot);

void PostOrder(PBTNode pRoot);
void W_PostOrder(PBTNode pRoot);

int SizeTree(PBTNode pRoot);
int GetLeafcount(PBTNode pRoot);
int Height(PBTNode pRoot);
int GetLayerBTNodeCount(PBTNode pRoot, int k);
PBTNode FindNode(PBTNode pRoot, BTDataType data);
void TestBinTree();

/********************* "BinTree.c" ************************/
#include <stdio.h>
#include <assert.h>
#include <malloc.h>
#include <string.h>

#include "BinTree.h"
#include  "Stack.h"


//创建节点
PBTNode BuyBinTreeBTNode(BTDataType data){
    PBTNode pNewBTNode = (PBTNode)malloc(sizeof(BTNode));
    assert(pNewBTNode);
    pNewBTNode->_pLeft = NULL;
    pNewBTNode->_pRight = NULL;
    pNewBTNode->data = data;
    return pNewBTNode;
}


//创建树
void _CreateBinTree(PBTNode* pRoot, BTDataType* array, int size, int* index, BTDataType invaild){
    assert(index);
    if (*index < size && invaild != array[*index]){
        *pRoot = BuyBinTreeBTNode(array[*index]);

        ++(*index);
        _CreateBinTree(&(*pRoot)->_pLeft, array, size, index, invaild);
        ++(*index);
        _CreateBinTree(&(*pRoot)->_pRight, array, size, index, invaild);
    }
}

void CreateBinTree(PBTNode* pRoot, BTDataType* array, int size, BTDataType invalid){
    int index = 0;
    _CreateBinTree(pRoot, array, strlen(array), &index, '#');

}

//拷贝树
PBTNode CopyBinTree(PBTNode pRoot){
    PBTNode pNewBTNode = NULL;
    if (pRoot){
        pNewBTNode = BuyBinTreeBTNode(pRoot->data);

        pNewBTNode->_pLeft = CopyBinTree(pRoot->_pLeft);
        pNewBTNode->_pRight = CopyBinTree(pRoot->_pRight);
    }
    return pNewBTNode;
}
//前序遍历 时间复杂度:O(N) 空间复杂度：最差递归深度 O(N)

void PreOrder(PBTNode pRoot){
    if (pRoot){
        printf("%c ", pRoot->data);
        PreOrder(pRoot->_pLeft);
        PreOrder(pRoot->_pRight);
    }

}



//中序遍历
void InOrder(PBTNode pRoot){
    if (pRoot){
        InOrder(pRoot->_pLeft);
        printf("%c ", pRoot->data);
        InOrder(pRoot->_pRight);
    }
}
//后序遍历
void PostOrder(PBTNode pRoot){
    if (pRoot){
        PostOrder(pRoot->_pLeft);
        PostOrder(pRoot->_pRight);
        printf("%c ", pRoot->data);
    }

}

//销毁树(后序)
void DestroyTree(PBTNode* pRoot){
    assert(pRoot);
    if (*pRoot){
        DestroyTree(&(*pRoot)->_pLeft);
        DestroyTree(&(*pRoot)->_pRight);
        free(*pRoot);
        *pRoot = NULL;
    }
}

//树对的节点数
int SizeTree(PBTNode pRoot){

    //int leftSize = 0;
    //int rightSize = 0;

    //if (NULL == pRoot){
    //  return 0;
    //}

    //leftSize = SizeTree(pRoot->_pLeft);
    //rightSize = SizeTree(pRoot->_pRight);
    //return leftSize + rightSize + 1;

    if (NULL == pRoot){
        return 0;
    }
    return SizeTree(pRoot->_pLeft) + SizeTree(pRoot->_pRight) + 1;
}

//叶子节点数
int GetLeafcount(PBTNode pRoot){
    if (NULL == pRoot)
        return 0;
    if (NULL == pRoot->_pLeft && NULL == pRoot->_pRight)
        return 1;
    return GetLeafcount(pRoot->_pLeft) + GetLeafcount(pRoot->_pRight);
}

//求高度
int Height(PBTNode pRoot){
    int leftHeight = 0;
    int rightHeight = 0;

    if (NULL == pRoot){
        return 0;
    }
    leftHeight = Height(pRoot->_pLeft);
    rightHeight = Height(pRoot->_pRight);

    return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}

//层数
int GetLayerBTNodeCount(PBTNode pRoot, int k){
    if (NULL == pRoot || k <= 0){
        return 0;
    }
    if (1 == k){
        return 1;
    }
    return GetLayerBTNodeCount(pRoot->_pLeft, k - 1) + GetLayerBTNodeCount(pRoot->_pRight, k - 1);

}


PBTNode FindNode(PBTNode pRoot, BTDataType data){
    PBTNode pNode = NULL;
    if (NULL == pRoot){
        return NULL;
    }
    if (pRoot->data == data){
        return pRoot;
    }
    if (pNode = FindNode(pRoot->_pLeft, data)){
        return pNode;
    }
    return FindNode(pRoot->_pRight, data);
}
//非递归前序遍历
void W_PreOrder(PBTNode pRoot){
    Stack s;
    if (NULL == pRoot)
        return;
    StackInit(&s);
    StackPush(&s, pRoot);

    while (!StackEmpty(&s)){
        PBTNode pCur = StackTop(&s);
        printf("%c ", pCur->data);

        StackPop(&s);
        if (pCur->_pRight){
            StackPush(&s, pCur->_pRight);
        }
        if (pCur->_pLeft){
            StackPush(&s, pCur->_pLeft);
        }
    }
}
void W_InOrder(PBTNode pRoot){
    Stack s;
    PBTNode pCur = pRoot;
    if (NULL == pRoot){
        return;
    }

    StackInit(&s);
    while(pCur || !StackEmpty(&s)){
        while (pCur){
            StackPush(&s, pCur);
            pCur = pCur->_pLeft;
        }
        pCur = StackTop(&s);
        printf("%c ", pCur->data);
        StackPop(&s);
        pCur = pCur->_pRight;
    }
    printf("\n");
}

void W_PostOrder(PBTNode pRoot){
    Stack s;
    if (NULL == pRoot){
        return;
    }
    PBTNode pCur = pRoot;
    PBTNode pTmp = NULL;
    PBTNode pTop = NULL;
    StackInit(&s);
    while (pCur || !StackEmpty(&s)){
        while (pCur){
            StackPush(&s, pCur);
            pCur = pCur->_pLeft;
        }

        pTop = StackTop(&s);
        if (NULL == pTop->_pRight || pTmp == pTop->_pRight){
            printf("%c ", pTop->data);
            pTmp = pTop;
            StackPop(&s);
        } 
        else{
            pCur = pTop->_pRight;
        }
    }

}

void TestBinTree(){
    char* pStr = "ABD###CE##F";
    PBTNode pRoot = NULL;

    PBTNode pNewBTNode = NULL;

    CreateBinTree(&pRoot, pStr, strlen(pStr), '#');

    pNewBTNode = CopyBinTree(pRoot);

    PreOrder(pRoot);
    printf("\n");

    InOrder(pRoot);
    printf("\n");

    PostOrder(pRoot);
    printf("\n");

    printf("TreeSize = %d\n", SizeTree(pRoot));
    printf("TreeLeafCount = %d\n", GetLeafcount(pRoot));

    printf("TreeHeight = %d\n", Height(pRoot));
    printf("TreeLayer = %d\n", GetLayerBTNodeCount(pRoot, 2));



    W_PreOrder(pRoot);
    printf("\n");

    W_InOrder(pRoot);
    printf("\n");

    W_PostOrder(pRoot);
    printf("\n");

    DestroyTree(&pRoot);

}


int main(){

    TestBinTree();
    return 0;
}
/********************** "Stack.h" ***********************/
#pragma once

#include "BinTree.h"

extern struct BTNode;

typedef BTNode* SDataType;

#define MAX_SIZE 10

typedef struct Stack{
    SDataType _array[MAX_SIZE];
    int _size;
}Stack;

void StackInit(Stack* s);
void StackPush(Stack* s, SDataType data);
void StackPop(Stack* s);
SDataType StackTop(Stack* s);
int StackSize(Stack* s);
int StackEmpty(Stack* s);


/********************** "Stack.c" ************************/
#include <stdio.h>
#include <assert.h>
#include <string.h>

#include "Stack.h"

void StackInit(Stack* s){
    assert(s);
    s->_size = 0;
}
void StackPush(Stack* s, SDataType data){
    assert(s);
    if (s->_size == MAX_SIZE)
        return;
    s->_array[s->_size++] = data;
}
void StackPop(Stack* s){
    assert(s);
    if (StackEmpty(s)){
        return;
    }
    s->_size--;

}
SDataType StackTop(Stack* s){
    assert(s);
    return s->_array[s->_size-1];
}
int StackSize(Stack* s){
    assert(s);
    return s->_size;
}
int StackEmpty(Stack* s){
    assert(s);
    return 0 == s->_size;
}