二叉树基础练习

binarytree.h

#include<stdio.h>
#include<windows.h>
#include<assert.h>

typedef int BTDataType;
typedef struct BinaryTreeNode
{
    struct BinaryTreeNode* _left;   //左孩子
    struct BinaryTreeNode* _right;  //右孩子
    BTDataType _data;               //数据域
}BTNode;//树的每个节点
#include"stack.h"
#include"queue.h"



BTNode *BuyNewNode(BTDataType x)//创建新节点
{
    BTNode *newnode = (BTNode *)malloc(sizeof(BTNode));
    assert(newnode);
    newnode->_data = x;
    newnode->_left = NULL;
    newnode->_right = NULL;
    return newnode;
}
BTNode *BinaryTreeCreateByPrev(int *a, int *index, int invalid)//先序创建二叉树
{
    //思路：
    //从数组头开始读取数据，遇到合法值，创建新节点，紧接着递归的创建左孩子和右孩子，V L R
    //遇到非法值时直接return NULL，创建完左右孩子return 当前节点的地址
    assert((*index) >= 0);
    if (a[*index] == invalid)
    {
        return NULL;
    }

    //到这一步时，可以判断数组的当前位置值为合法的，开始创建新节点
    BTNode *root = BuyNewNode(a[*index]);
    ++(*index);//数组下标后移
    root->_left = BinaryTreeCreateByPrev(a, index, invalid);//递归：创建左孩子
    ++(*index);//数组下标后移
    root->_right = BinaryTreeCreateByPrev(a, index, invalid);//递归：创建右孩子

                                                             //左右孩子都创建好，或者因非法return  NULL
                                                             //返回上层递归
    return root;

}
void BTreePrevOrder(BTNode *root)//先序，递归遍历二叉树   V L R
{
    //子问题：每个节点的左右孩子都要保证以R L T方式遍历
    //递归出口：抵达叶子节点，在向下遍历为空时

    if (root == NULL)
    {
        return;
    }
    //到这里说明还该处有节点，依照 V L R依次遍历,每个节点都是如此
    printf("%2d", root->_data);
    BTreePrevOrder(root->_left);
    BTreePrevOrder(root->_right);
}


void BTreeInOrder(BTNode* root)//中序遍历二叉树
{
    //子问题：每个节点的左右孩子必须按照L V R顺序遍历
    //递归出口：抵达叶子节点，在向下遍历为空时

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

void BTreePostOrder(BTNode* root)//后序遍历二叉树
{
    //子问题：每个节点的左右孩子都必须按照 L R V顺序遍历
    //递归出口：抵达叶子节点，在向下遍历为空时
    if (root == NULL)
    {
        return;
    }
    BTreePostOrder(root->_left);
    BTreePostOrder(root->_right);
    printf("%2d", root->_data);

}
size_t BTreeSize(BTNode* root)//二叉树的总结点数
{
    //子问题：一个树的节点个数都可以分解成 1 + 其左子树的节点个数 + 其右节点的节点个数
    if (root == NULL)
    {
        return 0;
    }

    return (1 + BTreeSize(root->_left) + BTreeSize(root->_right));
}
size_t BTreeLeafSize(BTNode* root)//二叉树的叶子节点数
{

    //如果树为空，返回0；
    //如果该节点为叶子节点，返回1
    //子问题：如果该节点不是叶子节点（有左右子树），返回其左子树的叶子节点个数 + 右子树节点个数
    if (root == NULL)
    {
        return 0;
    }
    if (root->_left == NULL&&root->_right == NULL)
    {
        return 1;
    }
    return BTreeLeafSize(root->_left) + BTreeLeafSize(root->_right);
}
size_t BTreeKLevelSize(BTNode* root, size_t k)//二叉树第k层节点数
{
    //子问题：如果当前层不是我们要查的，则k--，
    //且改为查其左子树的第k层的节点数+其右节点的第k层的节点数
    //递归出口：k==1，此时一定是我们要查的层数，返回当前节点数
    assert(k);//k至少为1
    if (root == NULL)
    {
        return 0;
    }
    if (k == 1)
    {
        return 1;
    }
    k--;
    return BTreeKLevelSize(root->_left, k) + BTreeKLevelSize(root->_right, k);
}
size_t BTreeDepth(BTNode* root)//二叉树的深度
{
    //子问题：从根结点开始，如果根节点有左右子树，那么他的深度为1+（左子树深度||右子树深度（取大值））
    //递归出口：如果当前节点已经是最深的节点，则返回0；
    if (root == NULL)
    {
        return 0;
    }
    size_t left = BTreeDepth(root->_left);
    size_t right = BTreeDepth(root->_right);
    return 1 + (left > right ? left : right);
}

void BTreeLevelOrder(BTNode* root)//广度遍历二叉树
{
    //思路：层序遍历需要借助一个队列完成，当根节点不为空时，将根节点指针入队，为空直接返回。
    //接着进入循环：如果队头节点有左节点或者右节点，则将他们的指针入队，然后对队头元素指针出队并打印，
    //直至队列为空
    Queue q;
    QueueInit(&q);
    if (root == NULL)
    {
        return;
    }
    QueuePush(&q, root);
    while (QueueEmpty(&q))
    {
        BTNode *front = QueueFront(&q);
        if (front->_left != NULL)
        {
            QueuePush(&q, front->_left);
        }
        if (front->_right != NULL)
        {
            QueuePush(&q, front->_right);
        }
        printf("%2d", front->_data);
        QueuePop(&q);
        free(front);
    }


}
BTNode* BTreeFind(BTNode* root, BTDataType x)//二叉树的查找
{
    //思路：若树为空树，则return NULL
    //      如果找到，return x的指针
    //      递归遍历左子树和右子树继续找
    if (root == NULL)
    {
        return NULL;
    }
    if (root->_data == x)
    {
        return root;
    }
    BTNode *ret = NULL;
    if (root->_left)
    {
        ret = BTreeFind(root->_left, x);
        if (ret)
        {
            return ret;
        }
    }

    if (root->_right)
    {
        ret = BTreeFind(root->_right, x);
        if (ret)
            return ret;
    }
    return NULL;
}


int IsCompleteBTree(BTNode* root)//判断一棵二叉树是否是完全二叉树
{
    //思路：完全二叉树的特性是前n-1层是满的，最后第n层的前k个是连续不间断的，后面不足无所谓。
    //那么就可以借助层序遍历，有左右子树就入队，没有对应的子树也入一个NULL进去，当第一次
    //遍历至NULL时，后面队列里的所有成员必须全是NULL，否则就不是完全二叉树（不满足连续）
    Queue q;
    QueueInit(&q);
    if (root == NULL)
    {
        return 0;
    }
    QueuePush(&q, root);
    while (QueueFront(&q) != NULL)
    {
        BTNode *front = QueueFront(&q);
        QueuePush(&q, front->_left);
        QueuePush(&q, front->_right);
        QueuePop(&q);
        free(front);
    }
    if (QueueEmpty(&q) == 0)
    {
        return 1;
    }
    else
    {
        while (QueueEmpty(&q))
        {
            if (QueueFront(&q) != NULL)
            {
                return 0;
            }
            QueuePop(&q);
        }
        return 1;
    }

}

void BTreePrevOrderNonR(BTNode* root)//前序非递归遍历二叉树
{
    //前序非递归遍历二叉树
    //思路：不用递归，可以用运营一个栈来模拟递归
    if (root == NULL)
    {
        return;
    }
    Stack s;
    StackInit(&s);
    BTNode *cur = root;
    while (cur || StackEmpty(&s))//cur不为空说明当前节点还可以遍历
    {                            //stack不为空说明栈内元素可能还有孩子没有被遍历
        while (cur)
        {
            printf("%d ", cur->_data);
            StackPush(&s, cur);
            cur = cur->_left;
        }
        //运行到这说明已经到达了最左节点，该遍历该节点的右子树了
        BTNode *top = StackTop(&s);
        cur = top->_right;
        //此处用cur记录了top的右节点，要及时出栈，否则如果有top有右子树，入栈后，就无法将top再出栈了
        StackPop(&s);

    }

}
void BTreeInOrderNonR(BTNode* root)//中序非递归遍历二叉树
{
    //思路与前序非递归类似，遇到一个节点时，先入栈，然后一直进入左子树
    Stack s;
    StackInit(&s);
    BTNode *cur = root;
    while (cur || StackEmpty(&s))//cur不为空说明当前节点还可以遍历
    {                            //stack不为空说明栈内元素可能还有孩子没有被遍历
        while (cur)
        {
            StackPush(&s, cur);
            cur = cur->_left;
        }
        //运行到这儿说明已经到达最左节点，该输出该节点了
        BTNode *top = StackTop(&s);
        printf("%d ", top->_data);
        cur = top->_right;//这里说明左孩子，中根节点已经遍历完毕，该右孩子遍历了
        StackPop(&s);
    }
}
void BTreePostOrderNonR(BTNode* root)//后序非递归遍历二叉树
{
    //后序非递归会比前序中序复杂一点，复杂的点就在于它的遍历顺序是左右中，
    //当把左孩子遍历完，该遍历右孩子了，这里cur会来到中根节点，当右孩子遍历完，cur又来到
    //中根节点，如何判断是否已经遍历右孩子？是后序遍历的关键。
    Stack s;
    StackInit(&s);
    BTNode *cur = root;
    BTNode *last = NULL;//新定义一个last记录右孩子是否遍历过，遍历过则将top->_right赋给last
    while (cur || StackEmpty(&s))
    {
        while (cur)
        {
            StackPush(&s, cur);
            cur = cur->_left;
        }
        BTNode *top = StackTop(&s);
        //如果此时发现top无右孩子或者右孩子已经被遍历过了，则直接输出top的data
        if (top->_right == NULL || last == top->_right)
        {
            printf("%d ", top->_data);
            StackPop(&s);
        }
        else
        {
            //进行到这里说明top有右孩子且尚未遍历过
            cur = top->_right;
            last = top->_right;

        }
    }
}

queue.h

typedef BTNode* QueueDataType;

typedef struct QueueNode
{
    QueueDataType _data;
    struct QueueNode* _next;
}QueueNode;

typedef struct Queue
{
    QueueNode* _head;
    QueueNode* _tail;
}Queue;

void QueueInit(Queue* q)
{
    assert(q);
    q->_head = NULL;
    q->_tail = NULL;
}

QueueNode* BuyQueueNode(QueueDataType x)
{
    QueueNode* node = (QueueNode*)malloc(sizeof(QueueNode));
    node->_data = x;
    node->_next = NULL;

    return node;
}

void QueuePush(Queue* q, QueueDataType x)
{
    assert(q);
    if (q->_tail == NULL)
    {
        q->_head = q->_tail = BuyQueueNode(x);
    }
    else
    {
        q->_tail->_next = BuyQueueNode(x);
        q->_tail = q->_tail->_next;
    }
}

void QueuePop(Queue* q)
{
    if (q->_head == NULL)
    {
        return;
    }
    else
    {
        QueueNode* next = q->_head->_next;
        free(q->_head);
        q->_head = next;

        if (q->_head == NULL)
        {
            q->_tail = NULL;
        }
    }
}

QueueDataType QueueFront(Queue* q)
{
    assert(q->_head);
    return q->_head->_data;
}

QueueDataType QueueBack(Queue* q)
{
    return q->_tail->_data;
}

size_t QueueSize(Queue* q)
{
    QueueNode* cur = q->_head;
    size_t size = 0;
    while (cur)
    {
        ++size;
        cur = cur->_next;
    }

    return size;
}

// 空 返回0
// 非空 返回1
int QueueEmpty(Queue* q)
{
    if (q->_head == NULL)
        return 0;
    else
        return 1;
}

stack.h

#pragma once
#include<stdio.h>
#include<windows.h>
#include<assert.h>
typedef BTNode* STDataType;
#define Stack_size 10
typedef struct Stack
{
    STDataType* _array;//数组指针
    size_t  _top; //栈顶 
    size_t  _end;//最大容量
}Stack;
// 栈的实现接口 
void StackInit(Stack* s)//栈的初始化
{
    assert(s);
    s->_array = (STDataType*)malloc(sizeof(STDataType)*Stack_size);
    s->_end = Stack_size;
    s->_top = 0;

}


void StackPush(Stack* s, STDataType x)//入栈
{
    assert(s);
    if (s->_end == s->_top)//栈已满
    {
        s->_end *= 2;
        s->_array = (STDataType*)realloc(s->_array, sizeof(STDataType)*(s->_end));
        s->_array[s->_top] = x;
        (s->_top)++;
    }
    else
    {
        s->_array[s->_top] = x;
        (s->_top)++;
    }
}


void Stack_print(Stack *s)
{
    if (s == NULL)
    {
        return;
    }
    while ((s->_top)--)
    {
        printf("%d\t", s->_array[s->_top]);
    }
}


void StackPop(Stack* s)//出栈
{
    assert(s);
    if (s->_top == 0)
    {
        printf("the stack is empty");
    }
    else
    {
        s->_top--;
    }
}


STDataType StackTop(Stack* s)//取栈顶元素
{
    assert(s);
    assert(s->_top);

        int num = s->_top;

        return  s->_array[(--num)];

}


size_t StackSize(Stack* s)//栈的长度
{
    assert(s);
    return s->_end;
}


int StackEmpty(Stack* s)//判断栈是否为空
{
    if (s->_top == 0)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}

test.c

#include"binarytree.h"


void test()
{
    int a[] = { 1, 2, 3, '#', '#',4,'#', '#', 5, 6,'#' ,'#' ,'#' };
    int index = 0;
    BTNode *root = BinaryTreeCreateByPrev(a, &index, '#');
    BTreePrevOrder(root);
    printf("\n");
    BTreeInOrder(root);
    printf("\n");
    BTreePostOrder(root);
    printf("\n");
    printf("该树有%d个节点\n", BTreeSize(root));
    printf("该树有%d个叶子节点\n", BTreeLeafSize(root));
    printf("该树第3层的节点数为%d\n", BTreeKLevelSize(root, 3));
    printf("该树的深度为%d\n", BTreeDepth(root));

    printf("%d\n", BTreeFind(root, 3)->_data);
    printf("%d\n", IsCompleteBTree(root));
    /*BTreePrevOrderNonR(root);
    printf("\n");
    BTreeInOrderNonR(root);
    printf("\n");
    BTreePostOrderNonR(root);*/
}

int main()
{
    test();
    system("pause");
    return 0;
}