栈和队列 小结

理论基础

栈和队列时操作受限制的线性表。

正是因为它们都是受限制的，所以采用顺序存储结构比较方便，因为顺序存储结构与链式存储结构的比较是，插入/删除操作比较不方便，需要移动元素，而此两种数据结构正好限制了插入删除操作。所以就使用顺序存储结构比较合理。

栈 ( 十分有用的数据结构, 递归调用 等等 )

    栈 ： 限制在表尾进行插入删除操作 ( 入栈 出栈 ， 后进先出 )

    队列 : （ 先进先出 , 如同现实的队列 )

    顺序栈  : 用一组地址连续的空间，存储。（常用 )  

    先为栈分配一个基本容量，然后在应用过程中，当栈的空间不够使用时再逐段扩大。

    push : top 向上，top + 1

    pop  : top 向下，top - 1

   

    定义 ： typedef struct {

                                   

                                      ElemType *base ;            //栈底指针

                                      ElemType *top ;               //栈顶指针

                                      int stacksize ;                  //栈的被分配空间

                             }SqStack ;

       空栈 : base = top

   借助高级语言数组 定义 ：typedef struct {

                                                 int data[ STACKSIZE ] ;   // stacksize 之前 ＃define

                                                 int base ;                         // 栈底 ( 用元素的坐标表示 )

                                                 int top ;                            // 栈顶

                                             }SqStack ;

 

   个人认为借助高级语言实现

              typedef struct {

                     ELEM_TYPE data[STACKSIZE];

                     int top;

               } sqstack; 

    因为 0 就是栈底， 不用再另外定义栈底

    这个是对的

   

   递归函数调用 用到栈 , 递归工作栈 , 可以自己用栈实现递归( 后续还有补充 )难点

    通常，在一个函数的运行期间调用另一个函数时，在运行被调用函数之前，系统需要完成3件事：

      1。将所有的实在参数，返回地址等信息传递给被调用函数保存。

      2。为被调用函数的局部变量分配存储区

      3。将控制转移到被调函数入口。

    从被调函数返回：

      1。保存被调函数的计算结果

      2。释放被调函数数据区

      3。依照被调函数的返回地址将控制转移到调用函数

    由于多个函数嵌套调用时，按照“后调用先返回”的原则。用栈实现。

  栈的应用举例很多。  ( 看下边例子,程序补充 )

    链栈 ：很少使用，详细请基本参考链表。

      很少使用的原因，个人觉得：由于链式结构之间的逻辑关系时依靠指针连接 *next ，特点是插入和删除操作时，不需要移动其他单元。

       由于栈规定了插入删除操作( 入栈 出栈 ) 只能在表尾(栈顶) 如果选择顺序结构也不涉及到元素一定( 入栈 出栈 时) , 所以选择顺序栈比较合适。

       而如果使用链栈则不仅要保存*next信息，还要保存 *base , *top 信息。

       综上,选择数据结构要根据操作的方便性。

  链栈的栈顶指针 应该是 链栈的首地址 ( 反着 )

  栈顶指针 -> 结点1 -> 结点2 -> 结点3 ......

  如下图 : 分析链栈存储结构

状态1 : top指针于base指针都是指向栈底，刚刚分配栈空间。

状态2 : 栈内存储数据，此时base指针不变，top指针增加，注意当再新增加数据时，只是找top指针，然后增加数据，并修改top指针。

状态3 : 出栈，首先可以找到top指针出栈，但是栈顶指针此时需要变更，无法找到它之前的元素，因为next指针只是向后，除非使用双链表。

            所以使用链栈时，出栈会有一点小麻烦。

队列  ( 跟栈相反 先进先出 ) ( 基本上都是循环队列,因为空间需要反复利用啊,要不就越来越浪费空间 )

  只准许在表的一端插入，而在另一个端删除。( 现实一致，删除的一端叫队头,出队 , 插入的一端叫队尾, 入队 )

  顺序队列 定义 ：定义 ： typedef struct {           基本上是循环队列(我们所说的顺序队列就是循环队列)

                                      ElemType *elem              //存储单元

                                      ElemType *front ;            //队头指针

                                      ElemType *rear ;             //队尾指针

                                      int queuesize ;                //队列的被分配空间

                             }SqQueue ;

  借助高级语言数组 实现 ：typedef struct {

                                                 int data[ SEQSIZE ] ;       // seqsize 之前 ＃define

                                                 int front ;                         // 队头 ( 用元素的坐标表示 )

                                                 int rear ;                          // 队尾

                                             }SqQueue ;

  顺序队列 特殊情况 ( 顺序队列不能通过 front = rear 判断 队列情况 )

 

  

 如上图 : 队列前端已经空了，但是此队列的状态时满的( 在想从 rear 插入数据已经不行了) 因此引入 循环队列

  因为不能通过 front = rear 判断队“满“ 或者 队”空“ ，则浪费一个存储空间，将 ( rear + 1 ) % 存储空间 ＝ front , 则判断为对满

 关键看谁追上谁，如果是 front 追上 rear , 空队列，如果是 rear 追上了 front 就是满队列.

 

  所以 一般的顺序队列叫做循环队列。

  链队列 定义 typedef struct QNode {        ( 不需要循环了)

                             QElemType elem ;           //存储单元

                             struct QNode *next ;        //指针

                       } QNode , *QueuePtr ;          // 结点定义

                       typedef struct {

                             QueuePtr front ;               //队头指针

                             QueuePtr rear ;               //队尾指针

                        } * LinkQueue ;  

  

  链队列同链表一样，也有头结点。  

  空队列 : front指针指向头结点 ， rear指针指向头结点。

  出入队列 : 从front指针出，从rear指针入。

                   出列时要修改头结点的next指针，而不时front所指向的头结点。( 当链队列中只有一个元素时,即出队列就变成空队列，此时不仅仅要修改头结点

                   的next指针，同时要修改 rear指针，指向头结点，因为此时已经时空队列 )

                   入队列时要修改 a3->next指针，指向新插入的元素并且要修改rear指针指向新插入的元素。

补充 : 表达式表示与求值 ( 详细参考 getchar & 表达式求值 )

实例推荐

  1. a( 练习册 3.10 递归实现 )

 

/* Use the recursion practic 3.10
** Author : kevin
** Date   : 2012/02/24
*/


#include"stdio.h"

void test( int sum )
{
    int x;
    scanf("%d",&x);
    if(x==0){
        sum = 0;
    }
    else{
        test(sum);
        sum += x ;
    }
    printf("%d,",sum);
}

int main()
{
    test(5);
    getchar();
    getchar();
}

1. b( 练习册 3.10 栈实现 )

/* Modify the recursion to stack practic 3.10
** Author : kevin
** Date   : 2012/02/24
*/

#include"stdio.h"
#include"stdlib.h"
#include"alloc.h"

typedef struct {
    int data[50];       /*store data*/
    int base ;          /*base*/
    int top ;           /*top*/
}SqStack ;

void InitStack( SqStack *ps)
{
    int i ;
    for(i=0; i<50; i++){
        ps->data[i] = 0;
    }
    ps->base = 0 ;
    ps->top = 0 ;
}

void PushStack( SqStack *ps , int e )
{
    int n ;
    n = ps->top ;
    ps->data[n] = e ;
    ps->top++;
}

int PopStack( SqStack *ps )
{
    int n ,e ;
    n = ps->top -1;
    e = ps->data[n] ;
    ps->top--;
    return e ;
}

int main()
{
    int x ;
    int sum ;
    int i ;
    int result ;
    SqStack sq ;
    InitStack( &sq);
    printf("Please input the sum value \n");
    scanf("%d",&sum);
    printf("\nPlease input the x value\n");
    scanf("%d",&x);
    for(;x!=0;){
        PushStack(&sq,x);
        scanf("%d",&x);
    }
    if(x==0){
        printf("%d,",x);
    }
    for(i=sq.top-1;i>=0;i--){
        result = PopStack(&sq);
        sum = 5;
        sum += result ;
        printf("%d,",sum);
    }
    getchar();
    getchar();

}/*Caution:This program value(sum),you can push the sum value into stack too , and that is the better*/

2.( 练习册 3.15 )

/* double direction stack , practice 3.15
** Author : kevin
** Date   : 2012/02/24
*/

#include"stdio.h"
#include"stdlib.h"
#include"alloc.h"

/*The define of stack*/
typedef struct {
    int data[50];       /*Save data , 50 is stack size*/
    int baseLeft ;      /*stack's left base*/
    int topLeft ;       /*stack's left top*/
    int baseRight ;     /*stack's right base*/
    int topRight ;      /*stack's right top*/
}SqStack ;

/*Init stack*/
void InitStack( SqStack *ps )
{
    int i ;
    for(i=0; i<50; i++){
        ps->data[i] = 0;
    }
    ps->baseLeft = 0 ;
    ps->topLeft = 0 ;
    ps->baseRight = 49;
    ps->topRight = 49 ;

}

/*Push stack*/
void PushStack( SqStack *ps , int i , int e)
{

    int n ;
    if(i==1){
        n = ps->topLeft;
        ps->data[n] = e ;
        ps->topLeft++ ;
    }else{
        n = ps->topRight;
        ps->data[n] = e ;
        ps->topRight-- ;
    }

}

/*Pop stack*/
int PopStack( SqStack *ps , int i )
{
    int n , e ;
    if(i==1){
        n = ps->topLeft;
        e = ps->data[n];
        ps->topLeft-- ;
        return(e);
    }else{
        n = ps->topRight;
        e = ps->data[n];
        ps->topRight++ ;
        return(e);
    }    
}

/*Display*/
void DisplayStack(SqStack *ps)
{
    int i ;
    printf("The first stack is \n");
    for(i=0;i<ps->topLeft;i++)
        printf("%d,",ps->data[i]);

    printf("\n");
    printf("The second stack is \n");
    for(i=49;i>ps->topRight;i--)
        printf("%d,",ps->data[i]);

}

int main()
{
    SqStack sq ;
    InitStack(&sq);
    PushStack( &sq , 1 , 100) ;
    PushStack( &sq , 1 , 200) ;
    PushStack( &sq , 1 , 300) ;
    PushStack( &sq , 1 , 400) ;
    PopStack( &sq , 1 ) ;
    PushStack( &sq , 2 , 10) ;
    PushStack( &sq , 2 , 20) ;
    PushStack( &sq , 2 , 30) ;
    PushStack( &sq , 2 , 40) ;
    PopStack( &sq , 2 ) ;
    DisplayStack( &sq);
    getchar();
}

3. ( 练习册 3.17 )

/* reverse sequence practice : 3.17
** Author : kevin
** Date   : 2012/02/24
*/

#include"stdio.h"
#include"stdlib.h"
#include"alloc.h"

typedef struct{
    char data[50];      /*Store the data*/
    int base ;          /*The base pointer*/
    int top  ;          /*The top pointer*/
}SqStack ;

/*Init the stack*/
void InitStack( SqStack *ps)
{
    int i ;
    for(i=0; i<50; i++){
        ps->data[i] = '';
    }
    ps->base = 0;
    ps->top = 0 ;
}

/*Push the value into stack*/
void PushStack( SqStack *ps , char c)
{
    int n ;
    n = ps->top ;
    ps->data[n] = c;
    ps->top++;

}

/*Pop the value */
char PopStack( SqStack *ps )
{
    int n ;
    char e ;
    n = ps->top ;
    e = ps->data[n];
    ps->top--;
    return e ;
}

void DisplayStack( SqStack *ps )
{
    int i ;
    for(i=0; i<ps->top;i++)
        printf("%c,",ps->data[i]);
}

int main()
{
    SqStack sq ;
    char c ;
    char result ;
    int status = 0 ;
    InitStack(&sq);

    while( (c=getchar())!='@'){                               --> 注意这的括号 ( ( c=getchar() ) != '@' )
        if(c=='&'){
            status = 1;
            DisplayStack(&sq);
            continue ;
        }

        if(status == 0 ){
            PushStack(&sq,c);
        }
        else{
            result = PopStack(&sq);
            if(result==c){
                continue ;
            }
            else{
                printf("NG , This is a not matched model");
                getchar();
                return 0 ;
            }

        }

    }
    printf("This is a correct model");
    getchar();
    getchar();
}

4. ( 练习册 3.19 )

/* bracket , practice 3.19
** Author : kevin
** Date   : 2012/02/24
*/

#include"stdio.h"
#include"stdlib.h"
#include"alloc.h"

typedef struct{
    char data[50];      /*Store the data*/
    int base ;          /*The base pointer*/
    int top  ;          /*The top pointer*/
}SqStack ;

/*Init the stack*/
void InitStack( SqStack *ps)
{
    int i ;
    for(i=0; i<50; i++){
        ps->data[i] = '';
    }
    ps->base = 0;
    ps->top = 0 ;
}

/*Push the value into stack*/
void PushStack( SqStack *ps , char c)
{
    int n ;
    n = ps->top ;
    ps->data[n] = c;
    ps->top++;

}

/*Pop the value */
char PopStack( SqStack *ps )
{
    int n ;
    char e ;
    n = ps->top -1 ;
    e = ps->data[n];
    ps->top--;
    return e ;
}

/*display the stack*/
void DisplayStack( SqStack *ps )
{
    int i ;
    for(i=0; i<ps->top;i++)
        printf("%c,",ps->data[i]);
}

int main()
{
    SqStack sq ;
    char c , result ;
    InitStack( &sq );
    while((c=getchar())!='\n'){
        if(c =='[' || c =='(' || c =='{'){
            PushStack(&sq,c);
        }
        else{
            if(c==')'){
                result = PopStack( &sq );
                if(result=='('){
                    continue;
                }else{
                    printf("NG , we can't match");
                    getchar();
                    getchar();
                }
            }
            else if(c=='}'){
               result = PopStack( &sq );
                if(result=='{'){
                    continue;
                }else{
                    printf("NG , we can't match");
                    getchar();
                    getchar();
                }
            }else{
               result = PopStack( &sq );
                if(result=='['){
                    continue;
                }else{
                    printf("NG , we can't match");
                    getchar();
                    getchar();
                }
            }
        }
    }
    printf("This is matched charactor");
    getchar();
    getchar();
}

5. ( 练习册 3.21 )                                               字符串操作 , 例如 复制 , 粘贴 要用特殊的函数 , 字符串操作困难

/* A little difficult , Expression reverse practice 3.21
** Author : kevin
** Date   : 2012/02/24
*/

/* The operater charactor precedence is   ) * / + - (         */


#include"stdio.h"
#include"stdlib.h"
#include"alloc.h"


/*operate charactor stack*/
typedef struct {
    char op[20];    /*Save operate charactor*/
    int top ;       /*top*/
    int base ;      /*base*/
}OpStack ;

/*s1 and s2*/
typedef struct {
    char *s[20];     /*Save s1 and s2 , sample : s1+s2 */
    int top ;
    int base ;
}SpStack ;

/*Expression reverse*/
typedef struct{
    char data[20] ; /*The result */
    int dp ;        /*The current pointer*/
}ExpResult;


void InitOpStack( OpStack * po )
{
    int i ;
    for(i=0; i<20; i++){
        po->op[20] = '';
    }
    po->op[0] = '#';
    po->base = 0;
    po->top = 1;
}

void InitSpStack( SpStack * ps )
{   
        int i ;
        for(i=0; i<20; i++)
            ps->s[i] = (char *)malloc(sizeof(char));    
    ps->base = 0;
    ps->top = 0 ;
}

void InitExpResult(ExpResult *pr)
{
    int i ;
    for(i=0; i<20; i++){
        pr->data[i] = '';
    }
    pr->dp = 0 ;
}


void PushOpStack( OpStack * po , char e)
{
    int n ;
    n = po->top;
    po->op[n] = e;
    po->top++;

}

char PopOpStack( OpStack * po )
{
    int n ;
    char e ;
    n = po->top -1;
    e = po->op[n] ;
    po->top--;
    return e ;
}



void PushSpStack( SpStack * ps , char *pe , int count )
{
    int n ,i ;
    char *p;
    p = pe;
    *(p+count) = '\0';
    n = ps->top;
    strcpy(ps->s[n],p);

    ps->top++;
}

char * PopSpStack( SpStack * ps )
{
    int n ;
    n = ps->top -1;
    ps->top--;
    return ps->s[n] ;
}

void DisplayExp( ExpResult *pe )
{
    int i ;
    for(i=0; i<=pe->dp; i++){
        printf("%c",pe->data[i]);
    }

}

void InsertExp( ExpResult *pe , char c )
{
    int n ;
    n = pe->dp ;
    pe->data[n] = c;
    pe->dp++;
}


int main()
{
   
    int exp_dp;
    int i ;
    char c ;
    char c_op ;
    char *s1 = NULL ;
    char *s2 = NULL ;
    char *p = NULL ;
    OpStack os ;
    SpStack ss ;
    ExpResult exp , exp_sub;
    InitOpStack(&os);
    InitSpStack(&ss);
    InitExpResult( &exp );
    InitExpResult( &exp_sub );
    while((c=getchar())!='#'){

        if( c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')' ){
            switch(c){
                case '+':
                case '-':
                    if( os.op[os.top-1] == '#' || os.op[os.top-1] == '+' || os.op[os.top-1] == '-' || os.op[os.top-1] == '('  ){
                        PushOpStack(&os,c);
                    }                                                                /*precedence more than stack top , only push into stack*/
                    else{                                                            /*precedence less than stack top , pop stack*/
                        s2 = PopSpStack(&ss);
                        s1 = PopSpStack(&ss);
                        c_op = PopOpStack(&os);
                        p = s1 ;
                        for(i=0 ; *(p+i)!= '\0';i++){
                            InsertExp(&exp,*(p+i));
                        }
                        p = s2 ;
                        for(i=0 ; *(p+i)!= '\0';i++){
                            InsertExp(&exp,*(p+i));
                        }
                        InsertExp(&exp,c_op);
                    }
                    break;
                case '*':
                case '/':
                    PushOpStack(&os,c);
                    break;
                case '(':
                    PushOpStack(&os,c);
                    break;
                case ')':
                    while( os.op[os.top - 1] !='('){
                          
                        s2 = PopSpStack(&ss);
                        s1 = PopSpStack(&ss);
                        c_op = PopOpStack(&os);
                        p = s1 ;
                        for(i=0 ; *(p+i)!= '\0';i++){
                            InsertExp(&exp_sub,*(p+i));
                        }
                        p = s2 ;
                        for(i=0 ; *(p+i)!= '\0';i++){
                            InsertExp(&exp_sub,*(p+i));
                        }
                        InsertExp(&exp_sub,c_op);
                        PushSpStack(&ss,exp_sub.data,exp_sub.dp);                               /* Push again */        
                        InitExpResult(&exp_sub);
                    }
                    if( PopOpStack(&os) =='('){
                        s1 =PopSpStack(&ss) ;
                        p = s1 ;
                        for(i=0 ; *(p+i)!= '\0';i++){
                            InsertExp(&exp,*(p+i));
                        }
                    }

                    break;
            }
        }else{
            PushSpStack(&ss,&c,1);                                 

        }
    }
    while(ss.top!=0){                           /*remain the s1 and s2 stack*/
        s1 = PopSpStack(&ss);
        p = s1 ;
        for(i=0 ; *(p+i)!= '\0';i++){
            InsertExp(&exp,*(p+i));
        }
    }
    while(os.op[os.top]!='#'){                           /*remain the s1 and s2 stack*/
        c_op = PopOpStack(&os);
        
        
            InsertExp(&exp,c_op);
   
    }

    printf("\n");
    DisplayExp(&exp);
    getchar();
    getchar();

}

6. ( 练习册 3.28 )

/* Circle Quene practice 3.28
** Author : kevin
** Date   : 2012/02/27
*/


#include"stdio.h"
#include"alloc.h"
#include"stdlib.h"


typedef struct QNode{
    int data ;                                
    struct MyLinkQueue * next ;
}QNode , *QueuePtr ;


typedef struct {
    QueuePtr rear ;                     
}*LinkQueue ;


LinkQueue InitQueue(){
    LinkQueue pr ;
    pr->rear = (QueuePtr)malloc(sizeof(QNode));    
    pr->rear->next = pr->rear ;                 
    return pr ;
}

void InQueue( LinkQueue pr , int a ){
    QueuePtr p ;
    p = (QueuePtr)malloc(sizeof(QNode));
    p->data = a ;
    p->next = pr->rear->next ;
    pr->rear->next = p ;
    pr->rear = p ;                  
}

void OutQueue( LinkQueue pr ){
    QueuePtr p ;
    p = pr->rear->next->next ;
    pr->rear->next->next = pr->rear->next->next->next ;
    free(p);    
}

void Display( LinkQueue pr ){
    QueuePtr p = pr->rear->next->next ;
    while( p!= pr->rear->next){
        printf("%d,",p->data);
        p = p->next ;    
    }    
}

int main(){
    LinkQueue pq ;
    pq = InitQueue() ;
    InQueue( pq , 1);
    InQueue( pq , 2);
    InQueue( pq , 3);
    Display(pq);
    OutQueue(pq);
    Display(pq);
    getchar();
        
}

7. 练习册 ( 3.31 )

/* huiwen Circle Queue practice 3.31
** Author : Kevin
** Date   : 2012/02/27
*/


#include"stdio.h"
#include"alloc.h"
#include"stdlib.h"

/*Node struct*/
typedef struct QNode{
    char data ;             /*Save the data*/
    struct QNode *next ;    /*next pointer*/
    struct QNode *prior ;   /*prior pointer*/
}QNode , *QueuePtr ;


/*Queue struct*/
typedef struct {
    QueuePtr phead ;        /*head pointer*/
    QueuePtr prear ;        /*rear pointer*/
}*LinkQueue;

LinkQueue InitQueue(){
    LinkQueue pr ;
    pr->phead = (QueuePtr)malloc(sizeof(QNode));
    pr->prear = pr->phead ;
    pr->phead->next = pr->phead ;
    pr->prear->prior = pr->prear ;
    return pr ;
}

void InQueue( LinkQueue pr , char a ){
    QueuePtr p ;
    p = (QueuePtr)malloc(sizeof(QNode));
    p->data = a ;
    p->next = pr->prear->next ;
    p->prior = pr->prear ;
    pr->prear->next = p ;
    pr->prear = p ;
}

void OutQueue( LinkQueue pr ){
    QueuePtr p ;
    p = pr->phead->next ;
    p->next->prior = pr->phead ;
    pr->phead->next = p->next ;
    free(p);    
}

void Huiwen(LinkQueue pr){
    QueuePtr p , q ;
    p = pr->phead->next ;
    q = pr->prear;
    while(p!=q){
        if(p->data ==q->data){
        }else{
            printf("Not huiwen");
            return 0;
        }
        p = p->next;
        q = q->prior;
    }
    printf("This is huiwen ");
}

void Display( LinkQueue pr ){
    QueuePtr p = pr->phead->next ;
    while( p!= pr->phead){
        printf("%d,",p->data);
        p = p->next ;    
    }    
}

int main(){
    char c ;
    LinkQueue pq ;
    pq = InitQueue() ;
    while((c=getchar())!='@'){
        InQueue(pq,c);
    }
    Huiwen(pq);
    getchar();
    getchar();
}


/* huiwen Circle Queue practice 3.31
** Author : Kevin
** Date   : 2012/02/27
*/


#include"stdio.h"
#include"alloc.h"
#include"stdlib.h"

/*Node struct*/
typedef struct QNode{
    char data ;             /*Save the data*/
    struct QNode *next ;    /*next pointer*/
    struct QNode *prior ;   /*prior pointer*/
}QNode , *QueuePtr ;


/*Queue struct*/
typedef struct {
    QueuePtr phead ;        /*head pointer*/
    QueuePtr prear ;        /*rear pointer*/
}*LinkQueue;

LinkQueue InitQueue(){
    LinkQueue pr ;
    pr->phead = (QueuePtr)malloc(sizeof(QNode));
    pr->prear = pr->phead ;
    pr->phead->next = pr->phead ;
    pr->prear->prior = pr->prear ;
    return pr ;
}

void InQueue( LinkQueue pr , char a ){
    QueuePtr p ;
    p = (QueuePtr)malloc(sizeof(QNode));
    p->data = a ;
    p->next = pr->prear->next ;
    p->prior = pr->prear ;
    pr->prear->next = p ;
    pr->prear = p ;
}

void OutQueue( LinkQueue pr ){
    QueuePtr p ;
    p = pr->phead->next ;
    p->next->prior = pr->phead ;
    pr->phead->next = p->next ;
    free(p);    
}

void Huiwen(LinkQueue pr){
    QueuePtr p , q ;
    p = pr->phead->next ;
    q = pr->prear;
    while(p!=q){
        if(p->data ==q->data){
        }else{
            printf("Not huiwen");
            return 0;
        }
        p = p->next;
        q = q->prior;
    }
    printf("This is huiwen ");
}

void Display( LinkQueue pr ){
    QueuePtr p = pr->phead->next ;
    while( p!= pr->phead){
        printf("%d,",p->data);
        p = p->next ;    
    }    
}

int main(){
    char c ;
    LinkQueue pq ;
    pq = InitQueue() ;
    while((c=getchar())!='@'){
        InQueue(pq,c);
    }
    Huiwen(pq);
    getchar();
    getchar();
}