定义：

对列只能选取一个端点进行插入，另一个端点进行删除操作。或者成为"先进先出的"存储结构。

对列的几个概念：

1. 把进行插入的一端称做队尾（rear）。
2. 进行删除的一端称做队首或队头（front）。
3. 向队列中插入新元素称为进队或入队，新元素进队后就成为新的队尾元素。
4. 从队列中删除元素称为出队或离队，元素出队后，其后继元素就成为队首元素。

链队代码：

也可以称为链表对列

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

typedef struct sqqueue//创建一个对列节点 共有两个成员变量，一个为数据  另一个为指向自身数据类型的节点的指针变量 
{
	int data;
	struct sqqueue * next;
}SqQueue;

typedef struct//创建一个结构体，结构体的成员为指向对列节点的指针变量 
{
	SqQueue * front;
	SqQueue * rear;
}Queue;

void InitQueue(Queue * pHeader)//创建一个头节点，创建队首队尾指针分别指向头节点，并不进行数据的赋值，只为操作方便 头结点数据域 指针域都为NULL
{
	pHeader->front = pHeader->rear = (SqQueue *)malloc(sizeof(SqQueue));
	if(pHeader->front == NULL)
	{
		printf("内存分配失败，退出程序\n");
		exit(-1);
	}
	else
	{
		pHeader->front->data = NULL;
		pHeader->front->next =NULL;
		printf("成功创建一个队列的头节点\n");
	}
}

bool CreatQueue(Queue * pNode,int e)  //进行进队操作
{
	SqQueue * pNew = (SqQueue * )malloc(sizeof(SqQueue));//动态生成新的内存，以及新的对列节点
	if(NULL == pNew)
	{
		printf("动态分配内存失败，程序终止\n");
		exit(-1);
		return 0;
	}
	else
	{
		pNew->data = e;
		pNew->next = NULL;
		//数据域赋值 指针域置为NULL  如果不置指针域为空  遍历以及销毁都会有一定问题，具体原因，我懒的去想，感觉就这问题 ，一调试就可以了
		pNode->rear->next = pNew;  //尾插法进行节点的延长，数据的扩展
		pNode->rear = pNew;//pNode->rear 为指针结构体的rear队尾指针前移，队尾指针指向新生成的节点元素
		return 1;
	}
}

bool DeQueue(Queue * pNode,int * e)
{
	if(pNode->front == pNode->rear&&pNode->front->data == NULL)  //加上pNode->front->data == NULL 的原因：防止最后那个元素不能进行出队
	{
		printf("对列为空，不能进行出队操作\n");
		return 0;
	}
	else
	{
		SqQueue * p;
		p = pNode->front->next; //pNode->front为头结点 头结点没有实际意义，要对下一个节点，也就是首节点进行操作，pNode->front->next为首节点
		*e = p->data;
		pNode->front->next = p->next;//将头结点指向 p->next == pNode->front->next->next
		free(p);
		return 1;
	}
}

bool GetHeader(Queue * pNode, int &e)
{
	if(pNode->front == pNode->rear||pNode->front->data == NULL)
	{
		printf("空队\n");
		return 0;
	}
	else
	{
		e = pNode->front->next->next->data;
		return 1;
	}
}

void DestryQueue(Queue * pNode )
{
	if(pNode->front == pNode->rear&&pNode->rear->data != NULL)
	{
		free(pNode->front);
	}
	else
	{
		SqQueue * p;
		int e = 0;
		p = pNode->front->next;
		while(p != NULL)
		{
			e = p->data;
			pNode->front->next = p->next;
			free(p);
			p = pNode->front->next;  //p依次遍历释放空间
		}
		pNode->front = pNode->rear;
	}
}

void TravelQueue(Queue * pNode)
{
	if(pNode->front == pNode->rear&&pNode->front->data != NULL)
	{
		printf("空队\n");
	}
	else
	{
		SqQueue * q;
		q = pNode->front->next;
		while(q != NULL)
		{
			printf("%d->",q->data);
			q = q->next;
		}

		printf("NULL\n");
	}
}

int main()
{
	Queue  q;  //创建一个结构体类型为Queue变量q 
	int e=0;
	InitQueue(&q);  //创建一个头结点  只为操作方便，不为进行赋值
	
	CreatQueue(&q,1);
	CreatQueue(&q,2);
	CreatQueue(&q,3);
	CreatQueue(&q,4);
	TravelQueue(&q);
	DeQueue(&q,&e);
	printf("%d\n",e);

	TravelQueue(&q);

	DestryQueue(&q);
	TravelQueue(&q);

}

循环对列代码：

地址为连续结构，也可以称为数组对列。

/*
	该程序是循环对列 
*/
# include <stdio.h>
# include <stdlib.h>

# define ElemType int
# define MaxSize 10

typedef struct  //定义一个数组类型的对列 
{     
	ElemType data[MaxSize]; 
    int front,count;      //队首 数量
}SqQueue;

void DestroyQueue(SqQueue *&q)
{
	free(q);//释放申请的内存区域
}

bool QueueEmpty(SqQueue *q)//判断相应的对列 区域是否为满
{
	return(q->count == 0);
}

void InitQueue(SqQueue *&q)
{
	q=(SqQueue *)malloc(sizeof(SqQueue));
	q->front=q->count=0;
}

bool enQueue(SqQueue *&q,ElemType e)//入队操作
{   int rear;   
	if (q->count==MaxSize)	//count为对列中的元素，不大于最大的MaxSize
	  return false;
	rear = (q->count+q->front)%MaxSize;//求队尾位置，从该处后面的位置入队
	rear = (rear+1)%MaxSize;
    q->data[rear]=e;
	q->count++;
    return true;
}

bool deQueue(SqQueue *&q,ElemType &e)//出队操作
{     
	if (q->count == 0)     //队空
		return false;
    q->front =(q->front+1)%MaxSize;
    e=q->data[q->front];
	q->count--;
    return true;
}

int main()
{
	SqQueue  * q;//定义一个结构体指针
	ElemType e;

	InitQueue(q); //初始化结构体指针 将结构体指针q 指向分配的内存空间

	enQueue(q,1);
	enQueue(q,2);
	enQueue(q,3);
	enQueue(q,4);
	
	printf("出队顺序:");
	while (!QueueEmpty(q))
	{
		deQueue(q,e);
		printf("%d ",e);
	}
	
	DestroyQueue(q);
	printf("\n");

	return 0;
}