数据结构---二叉树2（层序and非递归遍历）

二叉树层序遍历

非递归

//BT.h
#pragma once 

typedef int BTDataType;

typedef struct BinaryTreeNode
{
    struct BinaryTreeNode* _left;
    struct BinaryTreeNode* _right;
    BTDataType _data;
}BTNode;

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

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);

void BTreeLevelOrder(BTNode* root)
{
    Queue q;
    BTNode*cur = root;
    QueueInit(&q);
    if (cur != NULL)
    {
        QueuePush(&q, cur);
    }
    while (QueueEmpty(&q))
    {
        cur = QueueFront(&q);
        printf("%d ", cur->_data);
        QueuePop(&q);
        if (cur->_left)
            QueuePush(&q, cur->_left);
        if (cur->_right)
            QueuePush(&q, cur->_right);
    }
    printf("\n");
}
int IsCompleteBTree(BTNode* root)
{
    Queue q;
    BTNode*cur = root;
    QueueInit(&q);
    if (cur != NULL)
    {
        QueuePush(&q, cur);
    }
    while (QueueEmpty(&q))
    {
        cur = QueueFront(&q);
        QueuePop(&q);
        if (cur == NULL)
            break;
        else
        {
            QueuePush(&q, cur->_left);
            QueuePush(&q, cur->_right);
        }
    }
    while (QueueEmpty(&q))
    {
        cur = QueueFront(&q);
        if (cur != NULL)
            return -1;
        QueuePop(&q);
    }
    return 0;
}
int IsCompleteBTree1(BTNode* root)// flag的方式判断 
{
    Queue q;
    int flag = 0;
    BTNode*cur = root;
    QueueInit(&q);
    if (cur != NULL)
        QueuePush(&q, cur);
    while (QueueEmpty(&q))
    {
        cur = QueueFront(&q);
        QueuePop(&q);
        if (cur == NULL)
            break;
        else
        {
            if (cur->_left == NULL)
                flag = -1;
            else 
                QueuePush(&q, cur->_left);
            if (cur->_right == NULL)
                flag = -1;
            else
            {
                if (flag != 0)
                    return -1;
                QueuePush(&q, cur->_left);
            }
        }
    }
    return 0;
}
void BTreePrevOrderNonR(BTNode* root)
{
    BTNode*cur = root;
    Stack s;
    StackInit(&s, 10);
    if (root == NULL)
        return;
    //访问左树
    while (cur || StackEmpty(&s))
    {
        while (cur)
        {
            printf("%d ", cur->_data);
            StackPush(&s, cur);
            cur = cur->_left;
        }
        BTNode* top = StackTop(&s);
        StackPop(&s);
        //访问右树，子问题
        cur = top->_right;
    }
    printf("\n");
}
void BTreeInOrderNonR(BTNode* root)
{
    BTNode*cur = root;
    Stack s;
    StackInit(&s, 10);
    if (root == NULL)
        return;
    while (cur || StackEmpty(&s))
    {
        while (cur)
        {
            StackPush(&s, cur);
            cur = cur->_left;
        }
        BTNode*top = StackTop(&s);
        printf("%d ", top->_data);//访问根节点，左树已经访问完了。
        StackPop(&s);
        //访问右树，子问题
        cur = top->_right;
    }
    printf("\n");
}
void BTreePostOrderNonR(BTNode* root)
{
    BTNode*cur = root;
    BTNode*prev = NULL;
    Stack s;
    StackInit(&s,10);
    while (cur || StackEmpty(&s))
    {
        while (cur)
        {
            StackPush(&s, cur);
            cur = cur->_left;
        }
        BTNode*top = StackTop(&s);
        if (top->_right == NULL||top->_right==prev)
        {
            printf("%d ", top->_data);
            StackPop(&s);
            prev = top;
        }
        else
        {
            cur = top->_right;
        }
    }
    printf("\n");
}

BT.c

#include"BT.h"

void TestBinaryTree()
{
    int a[] = { 1, 2, 3, '#', '#', 4, '#', '#', 5, 6, '#', '#', '#' };
    size_t index = 0;
    BTNode* tree = CreateBTree(a, &index, '#');
    BTreePrevOrderNonR(tree);
    BTreeInOrderNonR(tree);
    BTreePostOrderNonR(tree);

    printf("BTreeKLevelSize?%d\n", BTreeKLevelSize(tree, 2));
    printf("IsCompleteBTree?%d\n", IsCompleteBTree1(tree));
    BTreeLevelOrder(tree);
}
int main()
{
    TestBinaryTree();
    system("pause");
    return 0;
}