基本数据结构

本章讲述了栈、队列、树、指针、对象的基本实现。boring AND difficult！！！

（1） 栈

概念定义：栈属于动态集合，采用先进后出策略（LIFO）。基本操作是压入（PUSH）和弹出（POP）。如果s.top=0，表示栈空，如果试图对空栈进行POP操作会发生下溢（underflow）。如果s.top>n,表示栈满，如果进行PUSH操作会发生上溢（overflow）。

基本代码

//基本的栈操作
#include <iostream>
#include <time.h>
using namespace std;
const n=10;
struct stack
{
    int top;
    int Array[n];
}s;
//初始化一个空栈
int Init_Stack()
{
    s.top = 0;//top为0表示空栈
    return 1;
}
//判断栈是否为空
bool stack_empty(int Array[])
{
    if (s.top==0)
    {
        return true;
    }
    else
    {
        return false;
    }
}
//入栈
void stack_push(int Array[],int x)
{
    if (s.top==n)
    {
        cerr<<"overflow!"<<endl;
    } 
    else
    {
        s.top++;
        s.Array[s.top]=x;
        
    }
}
//出栈
int stack_pop(int Array[])
{
    if (stack_empty(s.Array))
    {
        cerr<<"underflow"<<endl;
        return -1;
    }
    else
    {
        s.top--;
        return s.Array[s.top+1];
    }    
}
void main()
{
    struct stack s;
    Init_Stack();
    int x=0;
    srand( (unsigned)time( NULL ) );
    for ( int i=0;i<n;i++)
    {
        x=rand()%100;
        stack_push(s.Array,x);
    }
    for (i=0;i<n;i++)
    {
        cout<<stack_pop(s.Array)<<endl;
    }

}

（2） 队列

概念定义：队列属于动态集合，采用先进先出策略（FIFO）。基本操作是出队（enqueue）和出队（dequeue）。如果head=tail，表示队列为空，如果试图对空队列进行enqueue操作会发生下溢（underflow）。如果head=tail+1,表示队列满，如果进行dequeue操作会发生上溢（overflow）。

基本代码：

//基本的队列操作
#include <iostream>
#include <time.h>
using namespace std;
const n=5;
struct Queue
{
    int head;
    int tail;
    int Array[n];
}Q;
void Init_Queue()
{
    Q.head=Q.tail=1;//表示队列为空栈
}
//判断栈是否为空
bool Queue_empty(int Array[])
{
    if (Q.head==Q.tail)
    {
        return true;
    }
    else
    {
        return false;
    }
}
void ENQueue(int Array[],int x)
{
    if (Q.head==Q.tail+1)
    {
        cerr<<"overflow!"<<endl;
    } 
    else
    {
        Q.Array[Q.tail]=x;
        if (Q.tail==n)
        {
            Q.tail=0;
        }
        else
        {
            Q.tail++;
        }
    }
}
int DEQueue(int Array[])
{
    int x=0;
    if (Queue_empty(Q.Array))
    {
       cerr<<"underflow"<<endl;
    } 
    else
    {
        x=Q.Array[Q.head];
        if (Q.head==n)
        {
            Q.head=0;
        } 
        else
        {
            Q.head++;
        }
    }
   return x;
}
void main()
{
    struct Queue Q;
    Init_Queue();
    int x=0;
    srand( (unsigned)time( NULL ) );
    for ( int i=0;i<n;i++)
    {
        x=rand()%100;
        ENQueue(Q.Array,x);
    }
    for (i=0;i<n;i++)
    {
        cout<<DEQueue(Q.Array)<<endl;
    } 
}

（3）链表

 基本概念：链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序存储结构，操作复杂。

基本代码：

//书中双向链表无哨兵实现

#include <iostream>
#include <time.h>
using namespace std;
#define LEN sizeof(struct List)
struct List
{
    struct List*prev;
    struct List*next;
    struct List*head;
    int key;
};
//查找数据
struct List*search(struct List L,int k)
{
    struct List*x;
    x=L.head;
    while (x!=NULL&&x->key!=k)
    {
        x=x->next;
    }
    return x;
}
//插入数据
struct List*insert(struct List L,struct List*x)
{
   x->next=L.head;
   if (L.head!=NULL)
   {
       L.head->prev=x;
   }
   L.head=x;
   x->prev=NULL;
   return L.head;
}
//删除数据
struct List*Delete(struct List L,struct List*x)
{
   if (x->prev!=NULL)
   {
       x->prev->next=x->next;
   } 
   else
   {
       L.head=x->next;
   }
   if (x->next!=NULL)
   {
       x->next->prev=x->prev;
   }
   return L.head;
}
//打印数据
void Print(List L)  
{  
    struct List*p = L.head;  
    while(p)  
    {  
        cout<<p->key<<' ';  
        p = p->next;  
    }  
    cout<<endl;  
}  
void main()
{
   struct List L,*x,*t;
   srand( (unsigned)time( NULL ) );
   L.head=NULL;x=NULL;
   for (int i=0;i<10;i++)
   {
       x= (struct List*)malloc(LEN);
       x->key=rand()%100;
       if (i==6)
       {
           t=x;
       }
       L.head=insert(L,x);
   }
   Print(L);
   x=search(L,60);
   if (x==NULL)
   {
       cout<<"未找到数据！"<<endl;
   } 
   else
   {
       cout<<"已经找到数据"<<x->key<<endl;
   }
   L.head=Delete(L,t);
   Print(L);
}

书中双向链表有哨兵实现:

#include <iostream>
#include <time.h>
using namespace std;
#define LEN sizeof(struct List)
struct List
{
    struct List*prev;
    struct List*next;
    struct List*nil;
    int key;
};
struct List*Initialization(struct List &L)
{
   L.nil;
   L.nil=(struct List*)malloc(LEN);
   L.nil->next=L.nil;
   L.nil->prev=L.nil;
   return L.nil;
}
struct List*search(struct List &L,int k)
{
   struct List*x;
   x=L.nil->next;
   while (x!=L.nil&&x->key!=k)
   {
       x=x->next;
   }
   return x;
}
struct List*insert(struct List &L,struct List*x)
{
    x->next=L.nil->next;
    L.nil->next->prev=x;
    L.nil->next=x;
    x->prev=L.nil;
    return L.nil;
}
struct List*Delete(struct List &L,struct List*x)
{
    x->prev->next=x->next;
    x->next->prev=x->prev;
    return L.nil;
}
//打印数据
void Print(List L)  
{  
    struct List*p = L.nil->next; 
    if(p!=L.nil)
    {
        while(p!=L.nil)  
        {  
            cout<<p->key<<' ';  
            p = p->next;  
        }  
        cout<<endl; 
    }
    else
    {
        cout<<"此链表为空！"<<endl;
    }
} 
void main()
{
    struct List L,*x,*t;
    Initialization(L);
    Print(L);
    srand( (unsigned)time( NULL ) );
    x=NULL;
    for (int i=0;i<10;i++)
    {
        x= (struct List*)malloc(LEN);
        x->key=rand()%100;
        if (i==6)
        {
            t=x;
        }
        insert(L,x);
    }
    Print(L);
    x=search(L,60);
    if (x==L.nil)
    {
        cout<<"未找到数据！"<<endl;
    } 
    else
    {
        cout<<"已经找到数据"<<x->key<<endl;
    }
   Delete(L,t);
   Print(L);
}

（4）指针和对象的实现

基本概念：当有些语言不支持指针和对象数据类型时，我们可以用数组和数组下标构造对象和指针。这种链表称为静态链表。

对象的多数组和单数组表示基本的字典操作+申请分配内存

基本代码：

对象的多数组表示

     用三个数组next key prev 分别表示链表的后继 数据 前驱。

//由于有些语言不支持指针，所以我们可以用多数组表示的静态双链表。
#include <iostream>
#include <time.h>
#include <windows.h>
using namespace std;
#define MAX 10//于表头的前驱和表尾的后继都不存放元素，所以实际能存放的有效元素个数比MAX少2个
#define Null -1
int head=Null,Free=0;
int j=0;
struct List
{
    int next[MAX];
    int key[MAX];
    int prev[MAX];
};
int isIn(int *num,int index,int pat)//生成的随机数pat是否已经存在
{
    int i=0;
    for(i=0;i<index;++i)
        if(pat==num[i])
            return 1;
        return 0;   
}
int RAND(int *num)//随机抽取元素互异的key 这样key不会出现重复数值，易于以后的删除工作。
{
    int result=0;
    if (j>=MAX)
    {
        return Null;
    }
    while(1)
    {
        result=rand()%MAX;
        if(!isIn(num,j,result))
        {
            num[j]=result;
            j++;
            break;
        }
    }
    return result;
}
//链表初始化
void Initialization(struct List &T,int*num)
{
   Free=RAND(num);//[1,MAX-1]之间的数随机选择一个作为表头元素下标
   for (int i=0;i<MAX;i++)
   {
       T.key[i]=0;
       T.prev[i]=0;
   }
   int p=Free;
   for ( i=0;i<MAX-1;i++)
   {
       p=T.next[p]=RAND(num);
   }
   T.next[p]=Null;//链表最后的next指针为空。-1代表空
   j=0;//结构体T初始化后，临时数组num下标设置为0.
}  
//分配空间
int Allocate_object(struct List &T,int*num)
{
    if (Free==Null)
    {
        cerr<<"out of space!"<<endl;
        return Null;
    }
    else
    {    
      int x=Free; 
   Free=T.next[x];
      return x;
    }
}
//释放空间
void Free_object(struct List &T,int x)
{
   T.next[x]=Free;
   Free=x;
}
//插入数据
void insert(struct List &T,int k,int *num)
{
     int x=Allocate_object(T,num);//类似指针开辟一段内存空间
  if (x==Null)
  {
   return;
  }
  T.next[x]=head;
  T.key[x]=k;
  if (head!=Null)
  {
   T.prev[head]=x;
  }
  head=x;
  T.prev[x]=Null;
}
//查找数据
int search(struct List &T,int k)
{
   int t=head;
   if (head==Null)
   {
       cout<<"链表为空！无法查找！"<<endl;
       return Null;
   }
   while (t!=-1&&T.key[t]!=k)
   {
       t=T.next[t];
   }
   if (t==Null)
   {
       cout<<"不存在这个数据！"<<endl;
       return Null;
   } 
   else
   {
      cout<<"待查找数据已经找到！"<<endl;
      return t;//将待删除的数据下标返回，易于删除工作。
   }
}
//删除数据
void Delete(struct List &T,int k)//删除特定值的删除函数
{ 
    int p=0;
        p=search(T,k);
        if (p!=Null)
        {
       
            if (T.prev[p]!=Null)
            {
                T.next[T.prev[p]]=T.next[p];
            } 
            else
            {
                head=T.next[p];
            }
            if (T.next[p]!=Null)
            {
                T.prev[T.next[p]]=T.prev[p];
            }
            cout<<"删除成功！"<<endl;
            Free_object(T,p);
        } 
        else
        {
            cout<<"待删除的数据不存在！无法删除！"<<endl;
        }
}
void Print(struct List &T)
{
    int i=head;
    if (head==Null)
    {
        cout<<"此链表为空！"<<endl;
        return;
    }
    while (i!=Null)
    {
        cout<<T.key[i]<<"->";
        i=T.next[i];
    }
    cout<<endl;
}
void main()
{
    struct List T;
    srand((unsigned)time(NULL));
    int num[MAX]={0};//临时存放next[MAX]和key[MAX]数组的值，目的是用于生成互异的随机数
    cout<<"初始化链表中。";
    for( int j=0; j <= 100; j++ )      // 打印百分比   
     {  
      cout.width(3);  
      cout << j << "%";  
         Sleep(40);  
      cout << "";//退格符号  
  }  
    cout << "
";  
    Initialization(T,num);
    Print(T);
    cout<<"给链表添加数据中。";
 for(  j=0; j <= 100; j++ )      // 打印百分比   
 {  
  cout.width(3);  
  cout << j << "%";  
  Sleep(40);  
  cout << "";//退格符号  
 }  
    cout << "
"; 
    for (int i=0;i<MAX+1;i++)
    {
  int k=RAND(num);
        insert(T,k,num);
    }
    insert(T,35,num);
    Print(T);
    cout<<"查找数据中。";
 for(  j=0; j <= 100; j++ )      // 打印百分比   
 {  
  cout.width(3);  
  cout << j << "%";  
  Sleep(40);  
  cout << "";//退格符号  
 }  
 cout << "
"; 
    search(T,6);
    cout<<"删除数据中。";
 for( j=0; j <= 100; j++ )      // 打印百分比   
 {  
  cout.width(3);  
  cout << j << "%";  
  Sleep(40);  
  cout << "";//退格符号  
 }  
    cout << "
"; 
    Delete(T,0);
    Delete(T,2);
 Delete(T,5);
 Delete(T,500);
 insert(T,25,num);
 Print(T);
}

对象的单数组表示

     用一个数组即可表示双链表，这种表示法比较灵活，因为它允许不同长度的对象存储于同一数组中。一般地我们考虑的数据结构多是由同构的元素构成，因此采用对象的多数组表示法足够满足我们的需求。

以下的代码分别展示了基本的字典操作和如何申请分配内存。

//我们用key next prev表示双链表，如果array[i-1]为key,那么array[i]为next,array[i+1]为prev。
#include <iostream>
#include <time.h>
#include <windows.h>
using namespace std;
#define MAX 120
#define Null -1
int head=0,Free=0;
int isIn(int *num,int index,int pat)//生成的随机数pat是否已经存在
{
    int i=0;
    for(i=0;i<index;++i)
        if(pat==num[i])
            return 1;
        return 0;   
}
int RAND(int *num,int &j)//随机抽取元素互异的key 这样key不会出现重复数值，易于以后的删除工作。
{
    
    int result=0;
    if (j==0)
    {
        num[j]=head;j++;
    }
    while(1)
    {
        if (MAX/3==0)//防止被除数为0
        {
            return Null;
        }
        else
        {
            result=(rand()%(MAX/3)) * 3 + 1;
        }
        if(!isIn(num,j,result))
        {
            num[j]=result;
            j++;
            break;
        } 
    }
    return result;
}
//分配空间
int Allocate_object(int *Array,int*num)
{
    static x;
    if (Free==Null)
    {
        cout<<endl;
        cerr<<"out of space!"<<endl;
        return Null;
    }
    else
    {   
        x=Free;
        Free=Array[x];
        return x;
    }
}
//释放空间
void Free_object(int *Array,int x)
{
    Array[x]=Free;
    Free=x;
}
//链表初始化
void Initialization(int *Array,int*num,int &j)
{
    for (int i=0;i<MAX;i++)
    {
         Array[i]=0;
    }
    int p=RAND(num,j);
    Free=head=p;
    for (i=0;i<MAX/3-1;i++)
    {
         p=Array[p]=RAND(num,j);
    }
   Array[p]=Null;//链表最后的next指针为空。-1代表空
}
int insert(int *Array,int *num,int &j)
{
    static p=head,q=Null;
    int x=Allocate_object(Array,num);
    if (p!=Null)
    {
        Array[p-1]=rand()%MAX+1;
        Array[p+1]=q;
        q=p;
        p=Array[x];
    }
    else cout<<"链表开辟的内存空间不足！ 无法插入！"<<endl;
    return p;
}
//查找数据
int search(int *Array,int k)
{
    int t=head;
    if (Array[t-1]==0)
    {
        cout<<"链表为空！无法查找！"<<endl;
        return Null;
    }
    while (t!=-1&&Array[t-1]!=k)
    {
        t=Array[t];
    }
    if (t==Null)
    {
        cout<<"不存在这个数据！"<<endl;
        return Null;
    } 
    else
    {
        cout<<"待查找数据已经找到！"<<endl;
        return t;//将待删除的数据下标返回，易于删除工作。
    }
}
//删除数据
void Delete(int Array[],int k)//删除特定值的删除函数
{
    int p=0;
    p=search(Array,k);
    if (p!=Null)
    {
        if (Array[p+1]!=Null)
        {
            Array[Array[p+1]]=Array[p];
        } 
        else
        {
            head=Array[p];
        }
        if (Array[p]!=Null)
        {
            Array[Array[p]+1]=Array[p+1];
        }
        Free_object(Array,p);
        cout<<"删除成功！"<<endl;
    }
    else
    {
       cout<<"待删除的数据不存在！无法删除！"<<endl;
    }
}
void Print(int *Array)
{
    int i=head;int flag=1;
    if (Array[head-1]==0)
    {
        cout<<"链表为空！"<<endl;
        return;
    }
    while (flag)
    {
        if (Array[i]==Null)
        {
            flag=0;
        }
        cout<<Array[i-1]<<"	";
        i=Array[i];        
    }
}
void main()
{
    int Array[MAX];
    int num[MAX]={0};//临时存放数据的next指针的值，目的是用于生成互异的随机数
    int j=0;
    srand((unsigned)time(NULL));
    cout<<"初始化链表中。";
    for( int i=0; i <= 100; i++ )      // 打印百分比 
    {
        cout.width(3);
        cout << i << "%";
        Sleep(40);
        cout << "";//退格符号
    }
    cout << "
";
    Initialization(Array,num,j);
    Print(Array);
    cout<<"给链表添加数据中。";
    for(  i=0; i<= 100; i++ )      // 打印百分比 
    {
        cout.width(3);
        cout << i << "%";
        Sleep(40);
        cout << "";//退格符号
    }
    insert(Array,num,j);
    insert(Array,num,j);
    insert(Array,num,j);
    insert(Array,num,j);
    insert(Array,num,j);
    for ( i=0;i<MAX/3;i++)
    {
        insert(Array,num,j);
    }
    Print(Array);
    cout<<"查找数据中。";
    for(  i=0; i <= 100; i++ )      // 打印百分比 
    {
        cout.width(3);
        cout << i << "%";
        Sleep(40);
        cout << "";//退格符号
    }
    cout << "
";
    search(Array,5);
    cout<<"删除数据中。";
    for(  i=0; i <= 100; i++ )      // 打印百分比 
    {
        cout.width(3);
        cout << i << "%";
        Sleep(40);
        cout << "";//退格符号
    }
    cout << "
";
    Delete(Array,5);
    Delete(Array,6);
    Delete(Array,7);
    Delete(Array,7);
    Delete(Array,6);
    Print(Array);
}

（5）树

基本代码：

递归实现：

#include <iostream>
using namespace std;
#define LEN sizeof(struct Tree)
struct Tree
{
    int key;
    struct Tree*lchild;
    struct Tree*rchild;
};
//二叉树的创建
void create(struct Tree **p)
{
  *p=new struct Tree [LEN];
  cout<<"请输入二叉树key值:(按0结束当前分支输入)"<<endl;
  cin>>(*p)->key;
  static i=0;
  if ((*p)->key!=0)
  {
      create((&(*p)->lchild));
      create((&(*p)->rchild));
  }
}
//先序遍历递归过程。。。。（位置1）
void PreOderTraverse(struct Tree *p)
{//递归实现先序遍历
    if (p->key)
    {
        cout<<p->key<<" ";
        PreOderTraverse(p->lchild);
        PreOderTraverse(p->rchild);
    }
}
//中序遍历
void InOderTraverse(struct Tree *p)
{
    if (p->key)
    {        
        InOderTraverse(p->lchild);
        cout<<p->key<<" ";
        InOderTraverse(p->rchild);
    }
}
//后序遍历
void BackOderTraverse(struct Tree *p)
{
    if (p->key)
    {        
        BackOderTraverse(p->lchild);
        BackOderTraverse(p->rchild);
        cout<<p->key<<" ";
    }
}
void main()
{
    struct Tree *p=NULL;
    create(&p);
    cout<<"先序遍历："<<endl;
    PreOderTraverse(p);
    cout<<endl;
    cout<<"中序遍历："<<endl;
    InOderTraverse(p);
    cout<<endl;
    cout<<"后序遍历："<<endl;
    BackOderTraverse(p);
    cout<<endl;
}

循环实现：

栈实现：

.也可以用栈的数组实现，栈的实现，包括PUSH POP等栈操作全部自己实现。这个应该是符合《算法导论》10.4-3题目条件。

#include <iostream>
using namespace std;
#define LEN sizeof(struct Tree)
#define m 10//栈的最大容纳空间可以调整
struct Tree
{
    int key;
    struct Tree*lchild;
    struct Tree*rchild;
};
struct Stack
{
    int top;
    int Array[m];
    bool empty();
    void push(struct Tree*);
    int pop();
}s;
//判断栈是否为空
bool Stack::empty()
{
    if (s.top==-1)
    {
        return true;
    }
    else
    {
        return false;
    }
}
//入栈
void Stack::push(struct Tree*p)
{
    if (s.top==m)
    {
        cerr<<"overflow!"<<endl;
    } 
    else
    {
        s.top++;
        s.Array[s.top]=reinterpret_cast<int>(p);//将树形结构体的地址转化为整数储存到栈里面。
    }
}
//出栈
int Stack::pop()
{
    if (empty())
    {
        cerr<<"underflow"<<endl;
        return NULL;
    }
    else
    {
        s.top--;
        return s.Array[s.top+1];
    }    
}
void create(struct Tree **p)
{
  *p=new struct Tree [LEN];
  cin>>(*p)->key;
  static i=0;
  if ((*p)->key!=0)
  {
      create((&(*p)->lchild));
      create((&(*p)->rchild));
  }
} 
void PreOderTraverse(struct Tree *root)  
{  //用栈的数组实现，POP PUSH等函数全部自己来写
    if (root == NULL) return; 
    s.top=-1;
    s.push(root);
    struct Tree *p=root;
    while (!s.empty()) {   
        p=reinterpret_cast<struct Tree *>(s.Array[s.top]);//将数组中的数据恢复为编译器所能识别的指针
        cout<<p->key<<" ";
        s.pop();
        if (p->rchild->key != 0) 
        {
            s.push(p->rchild); 
        }
        if (p->lchild->key != 0) 
        {
            s.push(p->lchild);  
        }
    }  
    cout << endl;  
}
void main()
{
    struct Tree *p=NULL;
    create(&p);
    PreOderTraverse(p);
}

还有一种不用辅助栈，但需要父结点：

//(1). 访问左孩子
//(2). 访问右孩子
//(3). 如果是从右孩子返回，表明整棵子树已访问完，需要沿树而上寻找父节点。直到是从左孩子返回，或者访问到根节点的父节点
#include <iostream>
#include <stack>
using namespace std;
#define LEN sizeof(struct Tree)
struct Tree
{
    int key;
    struct Tree*lchild;
    struct Tree*rchild;
    struct Tree*parent;
};
void create(struct Tree **p)
{
    static struct Tree *p1=NULL;//p1保存当前结点的父亲结点
    *p=new struct Tree [LEN];
    cin>>(*p)->key;
    (*p)->parent=p1;
    p1=*p;
    if ((*p)->key!=0)
    {
        create((&(*p)->lchild));
        p1=*p;    
        create((&(*p)->rchild));
    }
}
void InOderTraverse(struct Tree *p)
{
   if(!p->key) return;
    struct Tree *x=NULL;
    while(1)
    {
        //访问左孩子
        if(x != p->lchild)
        {
            while(p->lchild->key) 
            {
                p=p->lchild;
            }
        }
        cout<<p->key<<" ";
        //访问右孩子
        if(p->rchild->key)
        {
            p=p->rchild;
            continue;
        }
        //回溯
        do
        {
            x=p;
            p=p->parent;
            //访问到根节点的父节点（NULL)
            if(!p) return;
        }while(x==p->rchild);
    }
}
void main()
{
    struct Tree *p=NULL;
    create(&p);
    InOderTraverse(p);
}

左孩子右兄弟表示多叉树:

//左孩子右兄弟表示多叉树
#include <iostream>
using namespace std;
#define LEN sizeof(struct Tree)
struct Tree*root=NULL;
struct Tree
{
    int key;
    struct Tree*left_child;
    struct Tree*right_sibling;
};
struct Tree*create(struct Tree**p)
{//注意创建多叉树的过程中，根结点没有右兄弟，所以最后回溯到根结点时，要把根节点的右兄弟设置为0.
  *p=new struct Tree[LEN];
  cin>>(*p)->key; 
  if ((*p)->key!=0)
  {
      create(&(*p)->left_child);
      create(&(*p)->right_sibling);
  }      
   return root;
}
//先序遍历递归过程
void PreOderTraverse(struct Tree *p)
{
    if (p->key)
    {
        cout<<p->key<<" ";
        PreOderTraverse(p->left_child);
        PreOderTraverse(p->right_sibling);
    }
}          
void main()
{
    struct Tree *p=NULL;
    create(&p);
    PreOderTraverse(p);
}

参考资料：

1、栈和队列的简单应用:

http://www.cnblogs.com/robinli/archive/2011/02/26/1965630.html

2、简单数据结构的理论升级：

http://blog.csdn.net/z84616995z/article/details/19202773