基本数据结构之栈和队列

前言：最近看各大公司的面试笔试题，发现对栈和队列的考察还是挺多，而且这两个都是经典的数据结构，我想虽然简单，但是基础非常重要，还是有必要总结总结；

1  栈的概念
   栈(Stack)：是限制在表的一端进行插入和删除操作的线性表。又称为后进先出LIFO (Last In First Out)或先进后出FILO (First In Last Out)线性表。
   栈顶(Top)：允许进行插入、删除操作的一端，又称为表尾。用栈顶指针(top)来指示栈顶元素。
   栈底(Bottom)：是固定端，又称为表头。
   空栈：当表中没有元素时称为空栈。

2 栈的实现：

  栈有两种实现，一种是顺序储存，一种是链式储存;

实现代码：

Stack.h

#define  MAX_STACK_SIZE  100      /*  栈向量大小  */
typedef  int  ElemType ;
//栈的顺序储存
/*typedef struct  sqstack
{  ElemType   stack_array[MAX_STACK_SIZE] ;
int  top;
int bottom;
}SqStack ;

SqStack Init_Stack();
void push(SqStack &S , ElemType  e);
void pop( SqStack &S, ElemType  &e );
*/

//栈的链式表示
typedef  struct  Stack_Node
{  ElemType   data ;
struct Stack_Node  *next ;
} Stack_Node ;

Stack_Node  *Init_Link_Stack(void);
void push(Stack_Node *top , ElemType  e);
void pop(Stack_Node  *top , ElemType *e);

Stack.c

#include "Stack.h"
#include <stdlib.h>
/*
SqStack Init_Stack(void)
{    SqStack  S ;
S.bottom=S.top=0 ;  
return(S) ;
}


void push(SqStack &S , ElemType  e)
{  if  (S.top==MAX_STACK_SIZE-1) 
return  ;  
S.stack_array[++S.top]=e  ;  
}


void  pop( SqStack   &S, ElemType  &e )
{  if ( S.top==0 )
return ;   
e=S.stack_array[S.top--] ;  
}
*/
//链表实现
Stack_Node  *Init_Link_Stack(void)
{    Stack_Node  *top ;
top=(Stack_Node  *)malloc(sizeof(Stack_Node )) ;
top->next=NULL ; 
return(top) ;
}

void push(Stack_Node *top , ElemType  e)
{   Stack_Node  *p ;
p=(Stack_Node  *)malloc(sizeof(Stack_Node)) ; 
if (!p)  return;
p->data=e ; 
p->next=top->next  ; 
top->next=p ;    /*  钩链  */
}
void pop(Stack_Node  *top , ElemType *e)
/*  将栈顶元素出栈  */
{   Stack_Node  *p ;
if  (top->next==NULL )
return ;
p=top->next ; 
*e=p->data ;    /*  取栈顶元素  */
top->next=p->next ;     /*  修改栈顶指针  */
free(p) ; 
}

main:

#include <stdio.h>
#include "Stack.h"
void main(){
	int e= 0;
	Stack_Node *s=Init_Link_Stack();
	push(s,1);
	push(s,2);
	pop(s,&e);
	printf("%d\n",e);
}

2 队列的基本概念
    队列(Queue)：也是运算受限的线性表。是一种先进先出(First In First Out ，简称FIFO)的线性表。只允许在表的一端进行插入，而在另一端进行删除。
    队首(front) ：允许进行删除的一端称为队首。
    队尾(rear) ：允许进行插入的一端称为队尾。
　　例如：排队购物。操作系统中的作业排队。先进入队列的成员总是先离开队列。 

实现：queue.h

#define  MAX_QUEUE_SIZE   100
typedef int ElemType;
//队列的顺序储存
/*
typedef  struct  queue
{  ElemType   Queue_array[MAX_QUEUE_SIZE] ;
int   front ;
int  rear ;
}SqQueue;

SqQueue Init_Queue(void);
void enQueue(SqQueue  &Q , ElemType  e);
void deQueue(SqQueue  &Q, ElemType  *x );
*/
//队列的链式储存
typedef struct Qnode
{  ElemType    data ;
struct Qnode  *next ;
}QNode ;
typedef struct link_queue
{   QNode  *front ,  *rear ;
}LinkQueue ;

LinkQueue *Init_LinkQueue(void);
void  enLinkQueue(LinkQueue  *Q , ElemType  e);
void  deLinkQueue(LinkQueue  *Q, ElemType *x);

queue.c

#include "queue.h"
#include <stdlib.h>
/*
SqQueue Init_Queue(void)
{  SqQueue  Q ;
Q.front=Q.rear=0;  
return(Q) ;
}

void enQueue(SqQueue  &Q , ElemType  e)
{  if(Q.rear==MAX_QUEUE_SIZE-1)
return ;
Q.Queue_array[Q.rear++]=e ; 
}

void deQueue(SqQueue  &Q, ElemType  *x )
{   if  (Q.front== Q.rear)
return  ;     
*x=Q.Queue_array[Q.front++] ; 
}
*/

LinkQueue *Init_LinkQueue(void)
{ 
QNode  *p=(QNode *)malloc(sizeof(QNode)) ; /* 开辟头结点 */
p->next=NULL ;
LinkQueue  *Q=(LinkQueue *)malloc(sizeof(LinkQueue)) ; 
        /*  开辟链队的指针结点  */
(*Q).front=(*Q).rear=p ; 
return(Q) ;
}

void  enLinkQueue(LinkQueue  *Q , ElemType  e)
      /*  将数据元素e插入到链队列Q的队尾  */
{   QNode* p=(QNode *)malloc(sizeof(QNode)) ;
if (!p)  return;
p->data=e ; 
p->next=NULL ;       /*  形成新结点 */
(*Q).rear->next=p ;  
(*Q).rear=p ;  /*  新结点插入到队尾  */
}

void  deLinkQueue(LinkQueue  *Q, ElemType *x)
   {   QNode *p ;
if  ((*Q).front==(*Q).rear)  return ;    /*  队空  */
p=(*Q).front->next ;   /*  取队首结点  */
*x=p->data ; 
(*Q).front->next=p->next ;      /*  修改队首指针  */
if  (p==(*Q).rear)  (*Q).rear=(*Q).front ;
     /*  当队列只有一个结点时应防止丢失队尾指针  */
    free(p) ;   
}

循环队列：

为充分利用向量空间，克服上述“假溢出”现象的方法是：将为队列分配的向量空间看成为一个首尾相接的圆环，并称这种队列为循环队列(Circular Queue)。
        在循环队列中进行出队、入队操作时，队首、队尾指针仍要加1，朝前移动。只不过当队首、队尾指针指向向量上界(MAX_QUEUE_SIZE-1)时，其加1操作的结果是指向向量的下界0。
这种循环意义下的加1操作可以描述为：
if  (i+1==MAX_QUEUE_SIZE)   i=0;
else     i++ ;
其中： i代表队首指针(front)或队尾指针(rear)

cirqueue.h

#define  MAX_QUEUE_SIZE   100
typedef int ElemType;

typedef  struct  queue
{  ElemType   Queue_array[MAX_QUEUE_SIZE] ;
int   front ;
int  rear ;
}SqQueue;

SqQueue Init_CirQueue(void);
int length(SqQueue Q);
void enCirQueue(SqQueue  Q , ElemType  e);
void deQueue(SqQueue  Q, ElemType  *x );

cirqueue.c

#include "cirqueue.h"

SqQueue Init_CirQueue(void)
{  SqQueue  Q ;
Q.front=Q.rear=0;  
return(Q) ;
}

int length(SqQueue Q){
	return (Q.rear-Q.front+MAX_QUEUE_SIZE)%MAX_QUEUE_SIZE;
}

void enCirQueue(SqQueue  Q , ElemType  e)
  /*  将数据元素e插入到循环队列Q的队尾  */
{  if  ((Q.rear+1)%MAX_QUEUE_SIZE== Q.front)
return  ;      /*  队满，返回    */
Q.Queue_array[Q.rear]=e ;   /*  元素e入队  */
Q.rear=(Q.rear+1)% MAX_QUEUE_SIZE ; 
}

void deQueue(SqQueue  Q, ElemType  *x )
   /*  将循环队列Q的队首元素出队  */
{   if  (Q.front+1== Q.rear)
return ;       /*  队空，返回错误标志    */
*x=Q.Queue_array[Q.front] ;  /* 取队首元素 */
Q.front=(Q.front+1)% MAX_QUEUE_SIZE ;
     /*  队首指针向前移动  */
}