数据结构复习2---栈和队列

0引言

栈和队列是操作受限的线性表。它们可以完成特殊的功能。由于它们本质上属于线性表，所以相关操作函数比较相似。
需要注意的是，队列一般使用循环队列，因此要注意掌握取模循环的运算方法。

1栈

1.1栈的结构体

#define MaxLen 100  //最大容量
typedef struct
{
	elementType data[MaxLen];　//存放栈元素
	int top;     //指示栈顶元素的位置
}seqStack;

1.2栈的运算实现

初始化栈

初始化栈顶为-1。

void initStack(seqStack * S)
{
    S->top = -1;
}

栈判空

bool stackEmpty( seqStack  S )
{
    if(S.top == -1)
	    return true;
    else
	    return false;
}

栈判满

bool stackFull( seqStack S ) 
{		  
	if ( S.top == MaxLen-1 )                    
	    return TRUE;     //栈满，返回true
	else 
	    return FALSE;   //栈不满，返回false
}

读栈顶元素

void stackTop(seqStack * S, elementType &x)
{
	if (S -> top == -1)
	    error(“栈空”);
	else
	    x=S->data[S->top];//参数x返回栈顶元素
}

压栈

压栈时，先移动栈顶指针，再将数据压栈。注意栈满错误。

void pushStack( seqStack * S, elementType x )
{ 
	 if ( S ->top == MaxLen-1 )  
           error(“栈满”);
	 else
     {  
           S -> top ++;                     //栈顶后移 
           S -> data [S -> top] = x ; //元素x入栈 
     }
}

弹栈

弹栈时，先取出数据，再移动栈顶指针。注意栈空错误。

void popStack(seqStack * S, elementType &x)
{ 
	  if (stackEmpty(*S)) 
             error(“栈空,不能删除”);
	  else
      {
             x=S->data［S->top］;  //取栈顶元素至x
             S->top--;   //栈顶减1，即删除了栈顶元素 
      } 
      //可用一行代码： x=S->data［S->top --］;            
}

2队列

2.1队列的结构体

循环队列需要有一个队头和一个队尾指针。两个指针都向高位生长，当超过最大值MaxLen时，循环为0；
队头指向的位置约定为一个保留的空间，不存储数据，因此数组最多存放MaxLen-1个元素。

typedef struct
{ 
   elementType  data[MaxLen];  // 存放元素
   int  front； //队头指针
   int  rear;   //队尾指针
}seqQueue;

2.2队列的运算实现

初始化

初始首尾都指向0，便于循环处理

void initQueue( seqQueue  &Q ) 
{
	Q.front=0;   //初始首尾都指向0，便于循环处理
	Q.rear=0; 
} 

判队空

队头和队尾之间是在排队的人，当队头就是队尾的时候，说明没人在排队。

bool queueEmpty(seqQueue  &Q) 
{     
	return(Q.front == Q.rear);  //简化写法
}

判队满

如果再加一个人，队尾到达队头，说明队列已经达到一个循环，由于约定保留一个空间，所以这个人不允许再加进来。

bool queueFull(seqQueue &Q)
{
	if((Q.rear+1)%MaxLen == Q.front)
		return TRUE;
	else
        return FALSE;
}

取队头

void queueFront(seqQueue &Q, elementType &x)
{
	if (Q.front==Q.rear) 
		error(“队空”);
	else                   //下式为什么取模呢？
		x=Q.data[(Q.front+1) % MaxLen];    
}

入队

入队的时候移动的是，队尾指针。先移动指针再写入数据。注意判断队满。

void enQueue(seqQueue & Q, elementType x)
{
	if((Q.rear+1)%MaxLen == Q.front)  //关键
         error(“队满”);
	else
    {
         Q.rear=(Q.rear+1) % MaxLen;     //关键
         Q.data[Q.rear]=x;
    }
}

出队

出队是对队头指针的操作，首先移动指针，再取出数据。注意判断队空。

void outQueue(seqQueue &Q ,elementType &x)
{
 	 if (Q.front == Q.rear)  
          error(“队空”);
  	 else
     {	
     	  Q.front = (Q.front+1)%MaxLen;    //关键
     	  x = Q.data[Q.front];   //捎带取出队头，非必须
     }
}