【无标题】

C语言 二叉树的层序遍历（非递归，利用栈和队列）

#include <stdio.h>
#include <stdlib.h>
#include<stdbool.h>
#define MAX 100
typedef struct node//build struct node
{
    int data;
    int tap;
    struct node* left;
    struct node* right;
} Node;


typedef struct
{
    Node* data[MAX];
    int top;
}Stack;

typedef struct queue
{
    Node* dataarr[MAX];
    int front;
    int rear;
}Sqqueue;
void initqueue(Sqqueue* que)
{
    que->front = 0;
    que->rear = 0;
}
void inqueue(Sqqueue* que, Node* p)
{
    que->dataarr[que->rear++] = p;
    //que->rear++;
}
Node* outqueue(Sqqueue* que)
{
    if (que->front != que->rear)
    {
        Node* e;
        e = que->dataarr[que->front++];
        //que->front++;
        return e;
    }
    else
    {
        printf("the queue is empty\n");
    }

}
void InitStack(Stack* sta)
{
    sta->top = -1;
}

void Isempty(Stack* sta)
{
    sta->top = -1;
}

void PushStack(Stack* sta, Node* p)
{
    sta->data[sta->top++] = p;
}

Node* PopStack(Stack* sta)
{
    return sta->data[--sta->top];
}
void PrintfStack(Stack* sta)
{
    if (sta->top == -1)
    {
        printf("the stack is empty\n");
    }
    else
    {
        printf("the stack is:");
        int p;
        p = sta->top;
        while (p != -1)
        {
            printf("%d ", sta->data[p]);
            p--;
        }
    }

    printf("\n");
}

void insert_node(Node* p, int value)//insert value into the root
{
    Node* node = malloc(sizeof(Node));//storage allocation
    node->data = value;
    node->left = NULL;
    node->right = NULL;


    Node* temp = p;//temporary node
    while (temp != NULL)
    {
        if (value < temp->data)
        {
            if (temp->left == NULL)
            {
                temp->left = node;
                return;
            }
            else
            {
                temp = temp->left;
            }
        }
        else
        {
            if (temp->right == NULL)
            {
                temp->right = node;
                return;
            }
            else
            {
                temp = temp->right;
            }
        }
    }



}
void leveinorder(Node* root)
{
    //Stack* sta;
    //sta = (Stack*)malloc(sizeof(Stack));
    //InitStack(sta);

    Sqqueue* que;
    que = (Sqqueue*)malloc(sizeof(Sqqueue));
    initqueue(que);

    Node* p;
    p = malloc(sizeof(Node));
    p = root;

    Node* temp;
    temp = malloc(sizeof(Node));


    inqueue(que, p);

    while (que->front != que->rear)
    {
        temp = outqueue(que);
        //PushStack(sta, temp);
        printf("%d ", temp->data);
        if (temp->left)
        {
            inqueue(que, temp->left);
        }
        if (temp->right)
        {
            inqueue(que, temp->right);
        }
    }


}
int main()
{
    int arr[5] = { 3,1,4,2,5 };
    Node* root = malloc(sizeof(Node));
    root->data = arr[0];
    root->left = NULL;
    root->right = NULL;

    int i;
    for (i = 1; i < 5; i++)
    {
        insert_node(root, arr[i]);
    }
    
    printf("the non-recursion of leveorder result:");
    leveinorder(root);
    printf("\n");


}