C语言数据结构_队列

链式队列

链式队列的实现思想同顺序队列类似，只需创建两个指针（命名为 front 和 rear）分别指向链表中队列的队头元素和队尾元素。

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

//链队的结点
typedef struct LinkNode{
	int data;
	struct LinkNode* next;
}*LinkNodePtr;

//链队列
typedef struct LinkQueue{
	LinkNodePtr front;
	LinkNodePtr rear;
}*LinkQueuePtr;

//初始化链队
LinkQueuePtr initQueue(){
	LinkQueuePtr resultPtr = (LinkQueuePtr)malloc(sizeof(struct LinkQueue));
	//创建链表的头结点
	LinkNodePtr headerPtr = (LinkNodePtr)malloc(sizeof(LinkNodePtr));
	headerPtr->next = NULL;
	//将队列的front和rear指针指向头结点
	resultPtr->front = headerPtr;
	resultPtr->rear = headerPtr;
	return resultPtr;
}
//输出队列元素
void outputLinkQueue(LinkQueuePtr paraQueuePtr){
	LinkNodePtr tempPtr = paraQueuePtr->front->next;
	while (tempPtr != NULL) {
		printf("%d ", tempPtr->data);
		tempPtr = tempPtr->next;
	}
	printf("\r\n");
}
//入队相当于尾插法
void enqueue(LinkQueuePtr paraQueuePtr, int paraElement) {
	//创建一个结点
	LinkNodePtr tempNodePtr = (LinkNodePtr)malloc(sizeof(LinkNodePtr));
	tempNodePtr->data = paraElement;
	tempNodePtr->next = NULL;
	
	//将该节点与链表连接
	paraQueuePtr->rear->next = tempNodePtr;
	
	//尾指针指向新的尾节点
	paraQueuePtr->rear = tempNodePtr;
}

int dequeue(LinkQueuePtr paraQueuePtr) {
	int resultValue;
	LinkNodePtr tempNodePtr;

	//判断队列是否为空
	if (paraQueuePtr->front == paraQueuePtr->rear) {
		printf("The queue is empty.\r\n");
		return -1;
	}

	//Step 2. Change the queue.
	tempNodePtr = paraQueuePtr->front->next;
	resultValue = tempNodePtr->data;
	paraQueuePtr->front->next = paraQueuePtr->front->next->next;
	//考虑到最后一个元素都出队了那么尾指针就必须指向头结点才能表示一个空的队列
	if (paraQueuePtr->rear == tempNodePtr) 
	{
		paraQueuePtr->rear = paraQueuePtr->front;
	}

	// free(tempNodePtr);
	tempNodePtr = NULL;

	return resultValue;
}

void testLinkQueue(){
	LinkQueuePtr tempQueuePtr;
	tempQueuePtr = initQueue();
	enqueue(tempQueuePtr, 10);
	enqueue(tempQueuePtr, 30);
	enqueue(tempQueuePtr, 50);

	outputLinkQueue(tempQueuePtr);

	printf("dequeue gets %d\r\n", dequeue(tempQueuePtr));
	printf("dequeue gets %d\r\n", dequeue(tempQueuePtr));
	printf("dequeue gets %d\r\n", dequeue(tempQueuePtr));
	printf("dequeue gets %d\r\n", dequeue(tempQueuePtr));


	enqueue(tempQueuePtr, 8);
	outputLinkQueue(tempQueuePtr);
}

int main(){
	testLinkQueue();
	return 1;
}

测试结果

10 30 50 
dequeue gets 10    
dequeue gets 30    
dequeue gets 50    
The queue is empty.
dequeue gets -1    
8

循环队列

用一维数组的形式来表示循环队列。在存储元素的时候通常是少用一个元素的空间，即队列空间大小为m时，有m-1个元素就队满。当头尾指针的值相等时则队列为空。而当尾指针在循环意义上加1后等于头指针时表示队满，因此在循环队列中队空队满的判断条件是：
队空条件：Q.fornt = Q.rear;
队满的条件：(Q.rear+1) % MAX_SIZE = Q.front;

创建一个空队

入队出队

入队出队

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

#define MAX_SIZE 5
typedef struct CirculateQueue
{
    int data[MAX_SIZE];
    int front;
    int rear;
}*CirculateQueuePtr;
//初始化队列
CirculateQueuePtr initQueue()
{
    CirculateQueuePtr resultPtr = (CirculateQueuePtr)malloc(sizeof(struct CirculateQueue));
    resultPtr->front = resultPtr->rear = 0;
    return resultPtr;
}
//入队
void enqueue(CirculateQueuePtr paraPtr,int paraValue)
{
    if((paraPtr->rear + 1) % MAX_SIZE == paraPtr->front)
    {
        printf("Queue is full!\n");
        return;
    }
    paraPtr->data[paraPtr->rear] = paraValue;
    paraPtr->rear = (paraPtr->rear + 1) % MAX_SIZE;
}
//出队
void dequeue(CirculateQueuePtr paraPtr)
{
    if(paraPtr->front == paraPtr->rear)
    {
        printf("Queue is empty!\n");
        return;
    }
    printf("deleteQueue is %d\n",paraPtr->data[paraPtr->front]);
    paraPtr->front = (paraPtr->front + 1) % MAX_SIZE;
}
//打印队的所有值
void outPutQueue(CirculateQueuePtr paraPtr)
{
    //当队头指针和队尾指针相等时队为空
    for(int i = paraPtr->front; i != paraPtr->rear; i = (i + 1) % MAX_SIZE)
    {
        printf("data[%d] = %d,",i,paraPtr->data[i]);
    }
    printf("\n");
}

int main()
{
    //创建一个队
    CirculateQueuePtr queue = initQueue();
    //入队10 11 12 13
    printf("enqueue from 10 to 16\n");
    for(int i = 10; i < 16; i++)
    {
        enqueue(queue,i);
    }

    outPutQueue(queue);
    //出队10 11 12 13
    printf("dequeue 5 times\n");
    for(int j = 1; j < 6; j++)
    {
        dequeue(queue);
    }
    //入队20 21 22 23
    printf("enqueue from 20 to 26\n");
    for(int k = 20; k < 26; k++)
    {
        enqueue(queue,k);
    }

    outPutQueue(queue);
    //出队20 21 22
    printf("dequeue 3 times\n");
    for(int m = 1; m < 4; m++)
    {
        dequeue(queue);
    }
    //入队30 31 32
    printf("enqueue from 30 to 36\n");
    for(int n = 30; n < 36; n++)
    {
        enqueue(queue,n);
    }
    outPutQueue(queue);
    return 0;
}

测试结果

PS D:\Data Struction> cd "d:\Data Struction\weekFour\student\" ; if ($?) { gcc circulateQueue2.c -o circulateQueue2 } ; if ($?) { .\circulateQueue2 }
enqueue from 10 to 16
Queue is full!
Queue is full!
data[0] = 10,data[1] = 11,data[2] = 12,data[3] = 13,
dequeue 5 times
deleteQueue is 10
deleteQueue is 11
deleteQueue is 12
deleteQueue is 13
Queue is empty!
enqueue from 20 to 26
Queue is full!
Queue is full!
data[4] = 20,data[0] = 21,data[1] = 22,data[2] = 23,
dequeue 3 times
deleteQueue is 20
deleteQueue is 21
deleteQueue is 22
enqueue from 30 to 36
Queue is full!
Queue is full!
Queue is full!
data[2] = 23,data[3] = 30,data[4] = 31,data[0] = 32,
PS D:\Data Struction\weekFour\student>