第三章学习小结

1.第三章学习了两种特殊的线性表----栈和队列。栈亦称为后进先出的线性表，LIFO，包括顺序栈和链栈；队列亦称为先进先出的线性表，FIFO，包括循环队列和链队。顺序栈和循环队列的定义和基本操作与第二章所学的顺序表有相似之处，链栈和链队与链表亦是如此。

一、栈

//顺序栈--栈顶进出 
const int MAXSIZE=100;
typedef int SElemType;   
typedef struct
{
    SElemType data[MAXSIZE];
    int top;   //栈顶标志 
    int stacksize;  //栈的最大容量 
}SqStack; 

void InitStack(SqStack &S)
{
    S.top=0;
    S.stacksize=MAXSIZE;
}

bool StackFull(SqStack &S)
{
    if(S.top==S.stacksize)   return true;
    else   return false;
}

bool StackEmpty(SqStack &S)
{
    if(S.top==0)   return true;
    else   return false;
}

void Push(SqStack &S, SElemType e) //栈顶入栈 
{//需先判断栈是否满 
    S.data[S.top]=e;
    S.top++; 
}

void Pop(SqStack &S, SElemType &e) //栈顶出栈 
{//需先判断栈是否空 
    S.top--;
    e=S.data[S.top];
}

//链栈--栈顶进出，无需设置头结点
typedef struct StackNode
{
    SElemType data;
    struct StackNode *next;
}StackNode, *LinkStack;

void InitStack(LinkStack &S)
{
    S=NULL;
}

bool StackEmpty(LinkStack S)
{
    if(S=NULL)   return true;
    else  return false;
}

Status Push(LinkStack &S, SElemType e)  //栈顶入栈 
{
    StackNode *p=new StackNode;
    if(p==NULL)   exit(OVERFLOW);
    p->data=e;
    p->next=S;
    S=p;
    return OK;
}

void Pop(LinkStack &S, SElemType &e)  //栈顶出栈 
{//需先判断栈是否空  
    StackNode *p;
    e=S->data;
    p=S;
    S=S->next;
    delete p;
}

注：递归与栈联系紧密，在计算机系统中，使用栈来实现递归。

二、队列

//循环队列--尾进头出 
const int MAXQSIZE=100;
typedef int QElemType;
typedef struct
{
    QElemType data[MAXQSIZE];
    int front;     //头指针 
    int rear;      //尾指针 
}SqQueue;

void InitQueue(SqQueue &Q)
{
    Q.front=Q.rear=0;
}

int QueueLength(SqQueue Q)
{
    return  (Q.rear-Q.front+MAXQSIZE) % MAXQSIZE;  //模运算 
}

bool QueueFull(SqQueue Q)
{
    if((Q.rear+1) % MASQSIZE==Q.front)    //模运算 
       return true;
    else   return false;
}

bool QueueEmpty(SqQueue Q)
{
    if(Q.front==Q.rear)
       return true;
    else   return false;
}

void EnQueue(SqQueue &Q, QElemType e)//队尾入队 
{//需先判断队是否满 
    Q.data[Q.rear]=e;
    Q.rear=(Q.rear+1) % MAXQSIZE;   //模运算 
}

void DeQueue(SqQueue &Q, QElemType &e)//队头出队 
{
    e=Q.tata[Q.front];
    Q.front=(Q.front+1) % MAXQSIZE;  //模运算 
}

//链队--尾进头出，设有头结点 
typedef struct QNode
{
    QElemType data;
    struct QNode *next;
}QNode, *QueuePtr;
typedef struct
{
    QueuePtr front;    //队头指针,始终指向头结点（无数据） 
    QueuePtr rear;     //队尾指针，始终指向最后一个结点 
}LinkQueue; 

Status InitQueue(LinkQueue &Q)
{
    Q.front=new QNode;
    if(Q.front==NULL)   exit(OVERFLOW);
    Q.front->next=NULL;
    Q.rear=Q.front;
    return OK;
}

bool QueueEmpty(LinkQueue Q)
{
    if(Q.front==Q.rear)    return true;
    else   return false;
}

Status EnQueue(LinkQueue &Q, QElemType e)
{
    QNode *p;
    p=new QNode;
    if(p==NULL)  exit(OVERFLOW);
    p->data=e;
    p->next=NULL;
    Q.rear->next=p;
    Q.rear=p;
    return OK;
}

void DeQueue(LinkQueue &Q, QElemType &e)
{//需先判断队是否空 
    QNode *p;
    p=Q.front->next;
    e=p->data;
    Q.front->next=p->next;
    if(Q.rear==p)   //最后一个结点出队 
       Q.front=Q.rear;
    delete p; 
}

注：队列中的链队涉及到模运算，不是简单的加减1而已。

我认为栈和队列的应用应该根据具体情况分析，数据的输入和输出、存储方式和处理方式共同影响着使用的线性表类型。由课本的案例，数制的转换、括号匹配的检验、表达式求值和舞伴问题，都展现了这一点。学好这两种线性表的定义和基本操作是基础，关键是对问题要有清楚的分析和清晰的逻辑思维。

2.做作业的判断题和单选题都是在看完课本才去做，编程题一般先自己看完，想想思路（一般想不出来），然后就看“带你打代码”，在完全理解逻辑之后再去pta复现的。做实践题之前，我总会先去看题目，然后先思索要使用什么类型的线性表来处理这个问题。有时候一直卡在一个点的时候，就去翻翻书，看看以前的问题，总能有不同的收获。有时实在想不出来，也会问问同学，虽然我们使用的线性表类型不同，但总会有不同的收获。这一次小组协作，我们可能一开始就在大方向上出现错误，一直想要使用顺序表来解决问题，但出现运行超市的问题，便考虑使用二分法，虽然还是没能解决这个问题，但最后使用链表终于完成了题目。

3.我觉得在现有能力下，书本是我最好的学习资料。无论多忙，一定要空出时间提前预习课本内容，到上课时一定会有意想不到的收获。

4.经过第三章的学习，感觉似乎对第二章的内容又复习了一遍。渐渐能完全理解这些定义和基本操作了。接下来还是要多打代码，用多种方式做pta的题，和同学相互借鉴。