数据结构第三章栈和队列笔记

目录

1.栈

1.1(1)顺序栈的表示

（2）顺序栈的初始化

（3） 顺序栈判断是否为空

(4)求顺序栈长度

(5)清空顺序栈

(6)销毁顺序栈

(7)顺序栈的入栈

 (8)顺序栈的出栈

1.2(1)链栈的表示

(2)链栈的初始化

(3)判断栈是否为空

(4)链栈的入栈

（5）链栈的出栈

(6)取栈顶元素

2.队列

2.1（1）循环队列的类型定义

(2)循环队列的初始化

(3)循环队列的长度

(4)循环队列入队

(5)循环队列出队

（6）取队头元素

2.2（1）链队列的类型定义

(2)链队列初始化

(3)销毁链队列

(4)链队列的操作--将元素e入队

(5)链队列的操作-链队列出队

(6)求链队列的队头元素

---

1.栈

栈(stack)是一个特殊的线性表，是限制仅在一端(通常是表尾)进行插入和删除操作的线性表。又称为后进先出的线性表，简称LIFO结构。

1.1(1)顺序栈的表示

#define MAXSIZE 100
typedef struct{
          SElemType  *base;//栈底指针
          SElemType  *top;//栈顶指针
          int stacksize;//栈可用最大容量
}SqStack;

（2）顺序栈的初始化

Status InitStack(SqStack &S){//构造一个空栈
   S.base= new SElemType[MAXSIZE];//或S.base=(SElemType*)malloc(MAXSIZE*sizeof(SElemType));
   if(!S.base) exit (OVERFLOW);//存储分配失败
   S.top=S.base;//栈顶指针等于栈底指针
   S.stacksize=MAxSIZE;
   return OK;
}

（3） 顺序栈判断是否为空

Status StackEmpty(SqStack S){
          //若栈为空，返回TRUE;否则返回FALSE
   if(S.top==S.base)
     return  TRUE;
   else
     return FALSE;
}

(4)求顺序栈长度

int StackLength(SqStack S){
               return S.top-S.base;
}

(5)清空顺序栈

Status ClearStack(SqStack S){
       if(S.base) S.top=S.base;
       return OK;
}

(6)销毁顺序栈

Status DestroyStack(SqStack &S){
        if(S.base){
          delete S.base;
          S.stacksize=0;
          S.base=S.top=NULL;
          }
    return OK;
}

(7)顺序栈的入栈

1.判断是否栈满，若满着出错(上溢)
2.元素e压入栈顶
3.栈顶指针加1

Status Push(SqStack &S,SElemType e){
      if(S.top-S.base==S.stacksize)//栈满
        return ERROR;
      *S.top=e;//*S.top++=e;
      S.top++;
      return OK;
}

 (8)顺序栈的出栈

 1.判断是否栈空，若空则出错(下溢)
2.栈顶指针减1
3.获取栈顶元素e

Status Pop(SqStack &S,SElemType &e){
 //若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK;否则返回ERROR
   if(S.top==S.base)///等价于if(StackEmpty(S))
     return ERROR;
   --S.top;
   e=*S.top;//e=*--S.top;
   return OK;
}

1.2(1)链栈的表示

链栈是运算受限的单链表，只能在链表头部进行操作

typedef struct StackNode{
     SElemType data;
     struct StackNode *next;
}StackNode,*LinkStack;
LinkStack S;

(2)链栈的初始化

void InitStack(LinkStack &S){
//构造一个空栈，栈顶指针置为空
    S=NULL;
    return OK;
}

(3)判断栈是否为空

Status StackEmpty(LinkStack S){
   if(S==NULL) return TRUE;
   else return FALSE;
}

(4)链栈的入栈

Status Push(LinkStack &S,SElemType e){
    p=new StackNode;//生成新的结点p
    p->data=e;//将新结点数据域置为e
    p->next=S;//将新结点插入栈顶
    S=p;//修改栈顶指针
    return OK;
}

（5）链栈的出栈

Status Pop(LinkStack &S,SElemType &e){
   if(S==NULL)return ERROR;
   e=S->data;
   p=S;
   S=S->next;
   delete p;
   return OK;
}

(6)取栈顶元素

SElemType GetTop(LinkStack S){
     if(S!=NULL)
     return S->data;
}

2.队列

队列(queue)是一种先进先出的线性表，在一端插入(队尾)，在另一端(队头)删除 。

2.1（1）循环队列的类型定义

#define MAXQSIZE 100//最大队列长度
typedef struct{
    QElemType *base//动态分配存储空间
    int front;//头指针，若队列不空，指向队列头元素
    int rear;//尾指针，若队列不空，指向队列尾元素的下一个位置
}SqQueue;

循环队列队满时判断方法--少用一个元素空间：

队满：（rear+1)%MAXQSIZE==front

队空：front==rear

(2)循环队列的初始化

Status InitQueue(SqQueue &Q){
   Q.base=new QElemType[MAXQSIZE];//分配数组空间
//Q.base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType));
   if(!Q.base) exit(OVERFLOW);//存储分配失败
   Q.front=Q.rear=0;//头指针尾指针置为0，队列为空
   return OK;
}

(3)循环队列的长度

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

(4)循环队列入队

Status EnQueue(SqQueue &Q,QElemType e){
      if((Q.rear+1)%MAXQSIZE==Q.front) return ERROR;//队满
      Q.base[Q.rear]=e;//新元素加入队尾
      Q.rear=(Q.rear+1)%MAXQSIZE;//队尾指针加1
      return OK;
}

(5)循环队列出队

Status DeQueue(SqQueue &Q,QELemType &e){
     if(Q.front==Q.rear) return ERROR;//队空
     e=Q.base[Q.front];//保存队头元素
     Q.front=(Q.front+1)%MAXQSIZE;//队头指针+1
     return OK;
}

（6）取队头元素

SElemType GetHead(SqQueue Q){
    if(Q.front!=Q.rear)//队列不为空
    return Q.base[Q.front];//返回队头指针元素的值，队头指针不变
}

2.2（1）链队列的类型定义

#define MAXQSIZE 100//最大队列长度
typedef struct QNode{
    QElemType data;
    struct QNode *next;
}QNode,*QueuePtr;

typedef struct {
      QueuePtr front;//队头指针
      QueuePtr  rear;//队尾指针
}LinkQueue;

(2)链队列初始化

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

(3)销毁链队列

算法思想：从队头结点开始，依次释放所有结点

Status DestroyQueue(LinkQueue &Q){
  while(Q.front){
     p=Q.front->next;free(Q.front);Q.front=p;
   }//Q.rear=Q.front->next;free(Q.front);Q.front=Q.rear;
  return OK;
}

(4)链队列的操作--将元素e入队

Status EnQueue(LinkQueue &Q,QElemType e){
       p=(QueuePtr)malloc(sizeof(ONode));
       if(!p) exit(OVERFLOW);
       p->data=e;p->next=NULL;
       Q.rear->next=p;
       Q.rear=p;
       return OK;
}

(5)链队列的操作-链队列出队

Status DeQueue（LinkQueue &Q,QElemType &e){
     if(Q.front==Q.rear) return ERROR;
     p=Q.front->next;
     e=p->data;
     Q.front->next=p->next;
     if(Q.rear==p) Q.rear=Q.front;
     delete p;
     return OK;
}

(6)求链队列的队头元素

Status GetHead(LinkQueue Q,QElemType &e){
   if(Q.front==Q.rear) return ERROR;
   e=Q.front->next->data;
   return OK;
}