이 진 트 리 옮 겨 다 니 기 - 비 재 귀적 방법 - C 언어 구현

이 진 트 리 의 비 재 귀적 달력: 선 서, 중 서, 후속, 층 서.
그 중에서 앞의 세 가 지 는 스 택 으로 노드 를 보조 적 으로 저장 하고 층 차 는 대기 열 을 이용 하여 노드 를 보조 적 으로 저장 했다.
뒷 순 서 는 앞의 두 가지 보다 약간 복잡 합 니 다. 루트 노드 는 마지막 으로 출력 되 기 때문에 모든 루트 노드 는 두 번 방문 해 야 합 니 다. 두 번 째 방문 시 출력 하려 면 보조 표 시 를 해 야 합 니 다.
문 제 를 간소화 하기 위해 이 진 트 리 도 간단 한 모양 입 니 다. ABC \ # \ # DE \ # \ # \ # FG \ # \ # \ # \ #   #빈 결산 점 을 대표 하 다.
물론 앞의 지식 점 과 연결 하기 위해 stack 과 queue 는 모두 자신 이 쓴 것 이 고 STL 용기 에 있 는 것 이 없 으 며 물론 용 기 를 바 꾸 어 쓰 면 간결 해 야 한다.
코드:

#include 
#include 
#include 

typedef struct BiTNode
{
    char data;
    struct BiTNode *lchild, *rchild;
}BiTNode, *BiTree;

typedef struct LNode
{
    BiTree tree;
    struct LNode *next;
    int lenght;
}LNode, *Linklist, *Quept;

typedef struct LinkQue
{
    Quept rear;
    Quept front;
}LinkQue;

void InitStack(Linklist &s)
{
    s = (LNode*)malloc(sizeof(LNode));
    s->next = NULL;
    s->lenght = 0;
}

void InitQueue(LinkQue &linkq)
{
    linkq.rear = linkq.front = (Quept)malloc(sizeof(LNode));
    linkq.front->next = NULL;
}

int EmptyQueue(LinkQue q)
{
    if(q.front->next == NULL)
        return 1;
    else
        return 0;
}

void CreatTree(BiTree &T)
{
    char e;
    e = getchar();
    if(e == '#')
        T = NULL;
    else
    {
        T = (BiTNode *)malloc(sizeof(BiTNode));
        T->data = e;
        CreatTree(T->lchild);
        CreatTree(T->rchild);
    }
}

void Push(Linklist &s, BiTree T)
{
    Linklist p;
    p = (LNode*)malloc(sizeof(LNode));
    p->tree = T;
    p->next = s->next;
    s->next = p;
    s->lenght++;
}

int EmptyStack(Linklist s)
{
    if(s->next != NULL)
        return 0;
    else
        return 1;
}

BiTree GetTop(Linklist s)
{
    BiTree t;
    t = s->next->tree;
    return t;
}

void Pop(Linklist &s)
{
    Linklist p;
    p = (LNode*)malloc(sizeof(LNode));
    p = s->next;
    s->next = p->next;
    free(p);
    s->lenght--;
}

void EnQueue(LinkQue &q, BiTree T)
{
    Quept p;
    p = (Quept)malloc(sizeof(LNode));
    p->tree = T;
    p->next = NULL;
    q.rear->next = p;
    q.rear = p;
}

BiTree DeQueue(LinkQue &q)
{
    Quept p;
    BiTree t;
    p = q.front->next;
    t = p->tree;
    q.front->next = p->next;
    if(q.rear==p) q.rear = q.front;
    free(p);
    return t;
}

void PreOrderTraverse(BiTree T)
{
    Linklist s;
    BiTree p;
    p = T;
    InitStack(s);
    while(p || !EmptyStack(s))
    {
        if(p)
        {
            printf("%c", p->data);
            Push(s, p);
            p = p->lchild;
        }
        else
        {
            p = GetTop(s);
            Pop(s);
            p = p->rchild;
        }
    }
    printf("
");
}

void InOrderTraverse(BiTree T)
{
    Linklist s;
    InitStack(s);
    BiTree p;
    p = T;
    while(p || !EmptyStack(s))
    {
        if(p)
        {
            Push(s, p);
            p = p->lchild;
        }
        else
        {
            p = GetTop(s);
            Pop(s);
            printf("%c", p->data);
            p = p->rchild;
        }
    }
    printf("
");
}

void PostOrderTraverse(BiTree T)
{
    Linklist s;
    InitStack(s);
    BiTree p, q;
    int mark[101]; //make sure the stack size is less than 100
    memset(mark, 0, sizeof(int));
    p = T;
    while(p || !EmptyStack(s))
    {
        if(p) //from the root node to traverse left child find the left corner node
        {
            Push(s, p);
            mark[s->lenght] = 0; //visit left tree node right tree node not visit set mark 0
            p = p->lchild;
        }
        else  //left tree node have traverse
        {
            if(mark[s->lenght] == 0) //right node not visit  visit right node
            {
                mark[s->lenght] = 1;
                p = GetTop(s);
                p = p->rchild;
            }
            else
            {
                q = GetTop(s);
                printf("%c", q->data);
                Pop(s);
            }
        }
    }
    printf("
");
}

void LevelOrderTraverse(BiTree T)
{
    BiTree p;
    LinkQue q;
    InitQueue(q);
    if(T)
    {
        EnQueue(q, T);
    }
    while(!EmptyQueue(q))
    {
        p = DeQueue(q);
        printf("%c", p->data);
        if(p->lchild) EnQueue(q, p->lchild);
        if(p->rchild) EnQueue(q, p->rchild);
    }

    printf("
");
}

int CountLeaves(BiTree T)
{
    if(T == NULL)
        return 0;
    else
    {
        if(T->lchild==NULL && T->rchild==NULL) return 1;
        return CountLeaves(T->lchild) + CountLeaves(T->rchild);
    }
}

int CountDepth(BiTree T)
{
    if(T==NULL)
        return 0;
    else
    {
        return (CountDepth(T->lchild)>CountDepth(T->rchild)?CountDepth(T->lchild):CountDepth(T->rchild)) + 1;
    }
}

int main()
{
    BiTree bitree;
    int leaves, depth;
    printf("Creating binary tree, e.g. ABC##DE###FG###, empty node use # .
");
    CreatTree(bitree);
    printf("PreOrder traverse tree:
");
    PreOrderTraverse(bitree);
    printf("InOrder traverse tree:
");
    InOrderTraverse(bitree);
    printf("PostOrder traverse tree:
");
    PostOrderTraverse(bitree);
    printf("LevelOrder traverse tree:
");
    LevelOrderTraverse(bitree);
    leaves = CountLeaves(bitree);
    printf("The tree leaves is %d.
", leaves);
    depth = CountDepth(bitree);
    printf("The tree depth is %d.
", depth);

    return 0;
}