链式队列

1.    熟悉队列的基本概念 

 

只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表  

进行插入操作的一端称为队尾（入队列）  

进行删除操作的一端称为队头（出队列）  

队列具有先进先出(FIFO)的特性

2. 队列的性质 

3. 队列存储结构 
   顺序队列 

 

底层结构为数组

队头指针不动----要大量搬移元素 

队头指针移动----存在假溢出 

 

假溢出：顺序队列因为多次入队列和出队列而导致的尚有储存空间而无法入队列

循环队列 

循环队列如何解决队列空或者满？ 

pHead为队头指针

pTail为队尾指针

这里的指针实际上是数组的下标

 

1，少用一个存储单元

      pHead向队头，pTail指向队尾的下一个空间

    设队列最大空间为MAX_SIZE

   （如果pTail+1）%MAX_SIZE=  队头指针，则队列为满

    如果pHead==pTail，则队列为空

  2，设置一个标记位

            pHead向队头，pTail指向队尾

 

      设置一个int  flag，当入栈时  flag=1，出栈时flag=0

      当pHead=pTail时，判断flag的值

             flag==0，队列空了

       flag==1，队列满了

  3，设置一个计数器、

     pHead向队头，pTail指向队尾

     设置一个int count==0计数器

           当pHead=pTail时，判断count的值

Count==MAX_SIZE时，队列满

Count==0时，队列空

     链式队列---用链表作为队列的底层数据结构 

头文件

#ifndef __QUEUE_H__
#define __QUEUE_H__

#include<stdio.h>
#include<assert.h>
#include<malloc.h>


typedef int DataType;
typedef struct Node
{
  DataType data;
  struct Node*next;
}Node,*PNode;

typedef struct Queue
{
  PNode pHead;
  PNode pTail;
}Queue;
//初始化
void QueueInit(Queue * q);

//入队列
void QueuePush(Queue* q,DataType data);

//出队列 
void QueuePop(Queue * q);

//获取队头元素
DataType QueueFront(Queue * q);

//获取队尾元素
DataType QueueBack(Queue * q);

//队列元素个数
int  QueueSize(Queue *q);

//判定队列是否为空
int  QueueEmpty(Queue *q );

//打印队列
void QueuePrint(Queue *q);

  


#endif //__QUEUE_H__

函数文件

#include"Queue.h"

void QueueInit(Queue * q)
{
  assert(q);
  q->pHead=NULL;
  q->pTail=NULL;
}

void QueuePush(Queue* q,DataType data)
{
	PNode NewNode;
    assert(q);
	NewNode =(PNode)malloc(sizeof(Node));
		  if(NewNode==NULL)
		  {
			  return ;
		  }
		  NewNode->next=NULL;

  if(q->pHead==NULL)//空队列
  {
         
		  q->pHead=q->pTail=NewNode;
		  q->pHead->data=data;
  }
  else//不是空
  {
    

	 q->pTail->next=NewNode;
	 q->pTail=q->pTail->next;
	 q->pTail->data=data;
  }
  
}

void QueuePop(Queue * q)
{
  PNode Del;
  assert(q);
  
  Del=q->pHead;
  q->pHead=q->pHead->next;
  free(Del);
  Del=NULL;
}

DataType QueueFront(Queue * q)
{
  assert(q);
  if(q->pHead==NULL)
  {
    return -1;
  }
  return q->pHead->data;
}


DataType QueueBack(Queue * q)
{
  assert(q);
  if(q->pTail==NULL)
  {
    return 0;
	
  }
  return q->pTail->data;
}


int  QueueSize(Queue *q)
{
	PNode pcur;
	int count =0;
    assert(q);
    pcur =q->pHead;
  while(pcur)
  {
    count++;
	pcur=pcur->next;
  }
  return count;
}

int  QueueEmpty(Queue *q )
{
  assert(q);
  if(q->pHead==NULL)
  {
    return 0;
  }
  return 1;
}

void QueuePrint(Queue *q)
{
	PNode cur=NULL;
  assert(q);
  if(q->pHead==NULL)
  {
     return;
  }
  cur=q->pHead;
  while(cur)
  {
	  printf("%d-->",q->pHead->data);
	  cur=cur->next;
  }

}

测试文件

#include"Queue.h"

Queue str;
DataType flag=0;//全局变量解决pop空队列返回值问题

void TestQueue()
{
	DataType ret=0;
  QueueInit(&str);

  QueuePush(&str,4);
  QueuePush(&str,5);

  ret=QueueFront(&str);

  ret=QueueBack(&str);

  QueuePop(&str);

  QueueSize(&str);

  QueueEmpty(&str);

  QueuePrint(&str);
}
int main ()
{
  TestQueue();
  return 0;
}