二叉树（周五实验）

#include <iostream>
#include<fstream>
using namespace std;

typedef struct TreeNode
{
    char data;
    int level;
    TreeNode* lchid;
    TreeNode* rchid;
}TreeNode;

char arr[20][2];//存放结点信息
bool visited[20]={0};//标记是否访问
int numlevel[20]={0};
int sum=1;//文件总行数加一

typedef struct StackNode
{
    TreeNode* data;
    StackNode* next;
}StackNode;

typedef struct QueueNode
{
    TreeNode* data;
    QueueNode* next;
    QueueNode* pre;
}QueueNode;

QueueNode* initQueue()
{
    QueueNode* Q = (QueueNode*)malloc(sizeof(QueueNode));
    Q->data = NULL;
    Q->next = Q;
    Q->pre = Q;
    return Q;
}

void enQueue(QueueNode* Q,TreeNode*T)
{
    QueueNode* node = (QueueNode*)malloc(sizeof(QueueNode));
    node->data = T;
    
    node->next = Q;
    node->pre = Q->pre;
    Q->pre->next = node;
    Q->pre = node;
}

bool isEmptyQ(QueueNode* Q)
{
    if (Q->next == Q)
        return true;
    return false;
}

QueueNode* deQueue(QueueNode* Q)
{
    if (isEmptyQ(Q) == true)
        return NULL;
    QueueNode* node = Q->next;

    Q->next->next->pre = Q;
    Q->next = Q->next->next;
    return node;
}

StackNode* initStack()
{
    StackNode* S = (StackNode*)malloc(sizeof(StackNode));
    S->data = NULL;
    S->next = NULL;
    return S;
}

void Push(TreeNode* data, StackNode* S)
{
    StackNode* node = (StackNode*)malloc(sizeof(StackNode));
    node->data = data;
    node->next = S->next;
    S->next = node;
}

int isEmptyS(StackNode* S)
{
    if (S->next == NULL)
        return 1;
    return 0;
}

StackNode* Pop(StackNode* S)
{
    if (isEmptyS(S))
        return NULL;
    StackNode* node = S->next;
    S->next = node->next;
    return node;
}

StackNode* GetPop(StackNode* S)
{
    if (isEmptyS(S))
        return NULL;
    StackNode* node = S->next;
    return node;
}

int SearchChild(int place)
{
    for (int i = 1; i < sum; i++)
    {
        //该节点未访问并且父亲等于搜索的结点
        if (visited[i] == 0 && arr[i][2] == arr[place][1])
            return i;
    }
    return -1;
}

void CreateTreeNode(TreeNode** T,int place,int pos)
{
    //没有该结点
    if (place == -1)
        (*T) = NULL;
    else
    {
        visited[place] = 1;
        //标记已经访问，防止多次访问

        char ch = arr[place][1];
        (*T) = (TreeNode*)malloc(sizeof(TreeNode));
        (*T)->data = ch;
        (*T)->level = pos;

        pos++;

        //寻找左孩子
        int nextplace1 = SearchChild(place);
        CreateTreeNode(&(*T)->lchid, nextplace1,pos);
        //寻找右孩子
        int nextplace2 = SearchChild(place);
        CreateTreeNode(&(*T)->rchid, nextplace2,pos);
    }
    
}

//先序遍历(递归)
void preOrderFun(TreeNode* T)
{
    if (T == NULL)
        return;
    else
    {
        //输出节点
        cout << T->data << " ";
        //左孩子
        preOrderFun(T->lchid);
        //右孩子
        preOrderFun(T->rchid);
    }
}

//中序遍历非递归
void inOrder(TreeNode* T)
{
    TreeNode* node = T;
    StackNode* S = initStack();
    while (node||!isEmptyS(S))
    {
        if (node)
        {
            Push(node, S);
            node = node->lchid;
        }
        else
        {
            node = Pop(S)->data;
            cout << node->data << " ";
            node = node->rchid;
        }
    }
}

void LevelNumber(TreeNode* T,QueueNode*Q)
{
    enQueue(Q, T);
    while (!isEmptyQ(Q))
    {
        QueueNode* node = deQueue(Q);
        numlevel[node->data->level]++;
        if (node->data->lchid)
            enQueue( Q,node->data->lchid);
        if (node->data->rchid)
            enQueue(Q, node->data->rchid);
    }
}

int main()
{
    fstream fp;
    fp.open("text.txt", ios::in);
    if (!fp)return 0;

    int place = 0;//找寻根节点
    while (!fp.eof())
    {
        fp >> arr[sum][1] >> arr[sum][2];
        if (arr[sum][1] == arr[sum][2]&&arr[sum][1]!='\0')
            place = sum;
        sum++;
    }

    int pos = 1;//层次

    TreeNode* T;
    CreateTreeNode(&T, place,pos);

    cout << "先序遍历:" << endl;
    preOrderFun(T);
    cout << endl;

    cout << "中序遍历:" << endl;
    inOrder(T);
    cout << endl;

    QueueNode* Q = initQueue();
    LevelNumber(T,Q);
    int i = 1;
    while (numlevel[i] != 0)
    {
        cout << numlevel[i] << endl;
        i++;
    }
}