深度优先遍历二叉树(DFS)

#include <iostream>
#include <stdio.h>
#include <malloc.h>

using namespace std;

#define STACK_INIT_SIZE 30
#define STACKINCREASE 10
typedef char ElemType;
typedef struct BiNode
{
    ElemType data;
    struct BiNode *lchild,*rchild;
}BiNode,*BiPtr;
typedef struct
{
    BiPtr *base;
    BiPtr *top;
    int stacksize;
}SqStack;

int InitStack(SqStack &S)
{
    S.base = (BiPtr *)malloc(STACK_INIT_SIZE*sizeof(BiPtr));
    if(!S.base)
    {
        cout << "分配空间失败!";
        exit(-1);
    }
    S.top = S.base;
    S.stacksize = STACK_INIT_SIZE;
    return 0;
}

int Push(SqStack &S,BiPtr e)
{
    if((S.top-S.base)>=STACK_INIT_SIZE)
    {
        S.base = (BiPtr *)realloc(S.base,(STACK_INIT_SIZE+STACKINCREASE)*sizeof(BiPtr));
        if(!S.base)
        {
            cout << "分配空间失败!";
            exit(-1);
        }
        S.top = S.base + STACK_INIT_SIZE;
        S.stacksize = STACK_INIT_SIZE + STACKINCREASE;
    }
    *(S.top) = e;//结构体
    S.top++;
    return 0;
}

int Pop(SqStack &S,BiPtr &e)
{
    if(S.base==S.top)
    {
        cout << "栈为空!";
        exit(0);
    }
    S.top--;
    e = *(S.top);
    return 0;
}

BiPtr GetTop(SqStack &S)
{
    if(S.base==S.top)
    {
        cout << "栈为空!";
        return 0;
    }
    else return *(S.top-1);//返回一个指针
}


int EmptyStack(SqStack &S)
{
    if(S.base==S.top) return 1;//stack is empty!
    else return 0;//stack is not empty!
}

//默认按前序遍历的顺序输入，尾结点用#表示
int Create_BiTree(BiPtr& T)
{
    ElemType c;
    //cout << "请输入当前节点元素值：" << endl;
    cin >> c;
    if(c == '#') T = NULL;
    else
    {
        T = new BiNode;
        T->data = c;
        Create_BiTree(T->lchild);
        Create_BiTree(T->rchild);
    }
    return 0;
}

//递归中序遍历二叉树
int InOrderTraverse(BiPtr T)
{
    if(T)
    {
        InOrderTraverse(T->lchild);
        cout << T->data << " ";
        InOrderTraverse(T->rchild);
    }
    return 0;
}
//非递归中序遍历二叉树 方法1
int InOrderTraverse1(BiPtr T)
{
    BiPtr p = T;
    SqStack S;
    InitStack(S);
    Push(S,T);
    while(!EmptyStack(S))
    {
        while(GetTop(S))
        {
            Push(S, p->lchild);
            p = p->lchild;//不停的“向左下走”
        }
        Pop(S, p);//前面会“走过头”，所以弹出多入栈的空指针
        if(!EmptyStack(S))
        {
            Pop(S, p);
            cout << p->data <<" ";
            Push(S, p->rchild);
            p = p->rchild;
        }
    }
   return 0;
}

//非递归中序遍历二叉树 方法2
int InOrderTraverse2(BiPtr T)
{
    BiPtr p = T;//从树根开始
    SqStack S;
    InitStack(S);
    while(p || !EmptyStack(S))//还有未访问的结点
        {
            if(p)//p向左下走到底并记录下沿途的节点
            {
                Push(S, p);
                p = p->lchild;
            }
            else//p走到了底，再依次弹出刚才路过却没有访问的节点，访问之，然后p向右走
            {
                Pop(S, p);
                cout << p->data <<" ";
                p = p->rchild;
            }
        }
    return 0;
}

int main()
{
    freopen( "input.txt", "r", stdin );//从input.txt中读取输入数据
    BiPtr T;
    Create_BiTree(T);
    InOrderTraverse(T);
    cout << endl;
    InOrderTraverse1(T);
    cout << endl;
    InOrderTraverse2(T);
    fclose(stdin);
    return 0;
}

input.txt的两组测试数据如下（分开测试，不是放同一个txt中的）：
ABC##D##E#F## 对应的遍历输出：C B D A E F
ABC##DEG#H###F#I##JK### 对应的遍历输出：C B G H E D F I A K J

上面例子中的两棵树如下：