数据结构链队和循环队列

目录

一.代码展示

1.链队列

2.循环队列

二.总结

---

一.代码展示

1.链队列

 

 

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


typedef struct LinkNode{
	int data;
	LinkNode *next;	
}*NodePtr;

typedef struct LinkQueue{
	NodePtr front;
	NodePtr near;
}*QueuePtr;

//初始化 
QueuePtr initQueue(){
	NodePtr H=(NodePtr)malloc(sizeof(NodePtr));
	printf("%d",sizeof(NodePtr));
	QueuePtr resultPtr=(QueuePtr)malloc(sizeof(QueuePtr));
	
	H->next=NULL;
	
	resultPtr->front=H;
	resultPtr->near=H;
	
	return resultPtr;
}

//输出队列
void outputQueue(QueuePtr paraQueue){
	NodePtr tempPtr=paraQueue->front->next;
	
	while(tempPtr!=NULL){
		printf("%d ",tempPtr->data);
		tempPtr=tempPtr->next;
	}
	
	printf("\r\n");
}

//插入新结点 
void enqueue(QueuePtr paraQueue,int paraValue){
	//创建新结点 
	NodePtr tempNode=(NodePtr)malloc(sizeof(NodePtr));
	tempNode->data=paraValue;
	tempNode->next=NULL;
	
	paraQueue->near->next=tempNode;
	paraQueue->near=tempNode; 
}

//删除结点并返回数据 
int dequeue(QueuePtr paraQueue){
	int resultValue;
	NodePtr tempPtr;;
	
	//判断是否为空 
	if(paraQueue->front==paraQueue->near){
		printf("队列为空！");
		return -1;
	}
	
	//
	tempPtr=paraQueue->front->next;
	resultValue=tempPtr->data;
	paraQueue->front->next=paraQueue->front->next->next; 
	
	if(paraQueue->near==tempPtr){
		paraQueue->near=paraQueue->front; 
	}
	
	free(tempPtr);
	tempPtr=NULL;
	
	return resultValue;
}
//测试 
void testLinkQueue(){
	QueuePtr tempQueuePtr;
	tempQueuePtr=initQueue();
	enqueue(tempQueuePtr,10);
	enqueue(tempQueuePtr,20);
	enqueue(tempQueuePtr,30);
	
	outputQueue(tempQueuePtr);
	
	printf("删除%d\r\n",dequeue(tempQueuePtr));
	outputQueue(tempQueuePtr);
	printf("删除%d\r\n",dequeue(tempQueuePtr));
	outputQueue(tempQueuePtr);
	printf("删除%d\r\n",dequeue(tempQueuePtr));
	outputQueue(tempQueuePtr);
	printf("删除%d\r\n",dequeue(tempQueuePtr));
	return ; 
}


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

输出样例

10 20 30
删除10
20 30
删除20
30
删除30

队列为空！删除-1

2.循环队列

 

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

#define SPACE 5

typedef struct  CircleInitQueue{
	int data[SPACE];
	
	int head;
	int tail;
}*CircleQueuePtr,LNode;

CircleQueuePtr initQueue(){
	CircleQueuePtr resultPtr=(CircleQueuePtr)malloc(sizeof(LNode));
	
	resultPtr->head=0;
	resultPtr->tail=0;

	return resultPtr;
} 

void enqueue(CircleQueuePtr paraQueue,int paraValue){
	//判断队列是否满 
	if((paraQueue->tail+1)%SPACE==paraQueue->head){
		printf("队列已满\r\n");
		return ;
	}
	
	paraQueue->data[(paraQueue->tail)%SPACE]=paraValue;
	paraQueue->tail++; 
}

int dequeue(CircleQueuePtr paraQueue){
	int resultValue;
	
	if(paraQueue->head==paraQueue->tail){
		printf("队列为空\r\n"); 
		return -1;
	} 
	
	resultValue=paraQueue->data[paraQueue->head%SPACE];
	paraQueue->head++;
	
	return resultValue;
}

void outputQueue(CircleQueuePtr paraQueue){
	int i;
	
	if(paraQueue->head==paraQueue->tail){
		printf("队列为空\r\n");
		return;
	}
	
	printf("队列的元素有: ");
	
	for(i=paraQueue->head;i<paraQueue->tail;i++){
		printf("%d ",paraQueue->data[i%SPACE]);
	}
	printf("\r\n");
}

void test(){
	int i=10;
	
	CircleQueuePtr tempPtr=initQueue();
	for(;i<16;i++){
		enqueue(tempPtr,i);
	}
	
	outputQueue(tempPtr);
	
	for(i=0;i<6;i++){
			printf("删除%d\r\n",dequeue(tempPtr));
	}
	
	enqueue(tempPtr,8);
	outputQueue(tempPtr);
}

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

测试样例

队列已满
队列已满
队列的元素有: 10 11 12 13
删除10
删除11
删除12
删除13
队列为空
删除-1
队列为空
删除-1
队列的元素有: 8

二.总结

队列是一种后进先出的数据结构，就像生活中我们排队一样，从队头删除，从队尾插入

循环队列：如果我们使用普通数组，随着出队和入队的进行，数组会向后移，因为数组前面的元素因为出队变成了空白，造成了空间的浪费。每出队一次，都将数组向前移，麻烦。所以我们使用循环队列，将队尾和队头连在一起。

回答问题：数组变量的空间分配连续，而链表的空间分配不连续。

局部变量只能在函数中使用，出了函数局部变量所调用的空间就会被收回。

指针变量的地址就是系统给他分配的那片空间的地址，而指针的值是指针所指向的地址中所存放的数据。