数据结构：队列的顺序表与链表的两种C语言实现

队列的基本概念

 

队列 (Queue) :是一种先进先出 (First In First Out ,简称 FIFO) 的线性表。只允许在表的一端进行插入,而在另一端进行删除。

 

队首 (front) :允许进行删除的一端称为队首。

 

队尾 (rear) :允许进行插入的一端称为队尾。

基本操作

void queue_init(queue *q);//初始化


void queue_en(queue *q,DataType data);//入队列


void queue_de(queue *q);//出队列


int  queue_Empty(queue *q);//队列判空


void get_head(queue *q);//获取队头元素


void queue_print(queue *q);//打印队列

 

void queue_clear(queue *q);//队列清空

顺序表：

queue.h   

#pragma once
 
#define MAX_QUEUE 100

typedef int DataType;

typedef struct queue
{
   DataType _arr[MAX_QUEUE];
   int _front;
   int _rear;
}queue;

void queue_init(queue *q);//初始化

void queue_en(queue *q,DataType data);//入队列

void queue_de(queue *q);//出队列

int  queue_Empty(queue *q);//队列判空

void get_head(queue *q);//获取队头元素

void queue_print(queue *q);//打印队列

void queue_clear(queue *q);//队列清空

queue.c

#include<stdio.h>
#include"queue.h"

void queue_init(queue *q)
{
   //构造一个空队列
	q->_front = q->_rear = 0;
    printf("初始化已完成！\n");
}

void queue_en(queue *q,DataType data)
{
	if(q->_rear == MAX_QUEUE)
	{
	   printf("队列已满！\n");
	   return;
	}
	q->_arr[q->_rear] = data;

	printf("元素%d入队\n",q->_arr[q->_rear]);

	q->_rear +=1;
}

void queue_de(queue *q)//出队列
{
 
   if(queue_Empty(q))
  {
     printf("队列为空");
	 return ;
  }
  
   printf("元素%d出队\n",q->_arr[q->_front]);

   q->_front += 1;
}

int  queue_Empty(queue *q)
{
	if(q->_front == q->_rear)
	{
	   printf("队列为空");
	   return 1;
	}
	return 0;
}

void get_head(queue *q)//获取队头元素
{
  if(queue_Empty(q))
  {
     printf("队列为空");
	 return ;
  }
  printf("对头元素为：%d\n",q->_arr[q->_front]);

}

void queue_print(queue *q)
{
	int i = 0;
	
	if(q->_front == q->_rear)
	{
	  printf("队列为空！\n");
	  return;
	}
     
    printf("开始打印：\n");
	for(i = q->_front;i<q->_rear;i++)
	{
		printf("%d ",q->_arr[i]);
	}

	printf("\n");
}

void queue_clear(queue *q)
{
	q ->_front = q ->_rear = 0;
}

int main()
{
	queue q;

    queue_init(&q);

    queue_en(&q,1);
	queue_en(&q,2);
	queue_en(&q,3);
	queue_print(&q);

    queue_de(&q);
	queue_print(&q);

	get_head(&q);

   return 0;
}

 

队列的链式表示和实现

队列的链式存储结构简称为链队列,它是限制仅在表头进行删除操作和表尾进行插入操作的单链表。

给队列添加一个头结点，并令头指针指向头结点

 

 

queue.h

 

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

typedef int DataType;
typedef struct q_node
{
   DataType _data;
   struct q_node *next;
}q_node,*link_node;
typedef struct queue
{
   q_node* front;
   q_node* rear;
}queue;

void queue_init(queue *q);//队列初始化

void queue_en(queue *q , int data);//入队列

void queue_de(queue *q);//出队列

int queue_Empty(queue *q);//队列判空

void get_front(queue *q);//获取队头

void queue_print(queue *q);//打印队列

void queue_destroy(queue *q);//销毁队列

queue.c

#include"queue.h"

void queue_init(queue *q)
{
	q->front = (q_node*)malloc(sizeof(q_node));
	if(q->front != NULL)
	{
		q->rear = q->front;
		q->front->next = NULL;
	}//头指针和尾指针都指向头节点，且头节点为空
	printf("初始化成功！\n");
}


void queue_en(queue *q , int data)
{
   link_node new_node = (link_node)malloc(sizeof(q_node));
   if(!new_node)
   {
      printf("内存分配失败在\n");
	  return ;
   }

   new_node ->_data = data;
   new_node ->next = NULL;
   q->rear->next  = new_node;
   q->rear = q->rear->next;
  
   printf("%d入队\n",q->rear->_data);
}


void queue_de(queue *q)
{
   link_node del_node = NULL;
   assert(q);
   if(q->front ==q->rear)
   {
      printf("队列为空\n");
	  return ;
   }
   printf("%d出队\n",q->front->next->_data);

   del_node  = q->front->next;
   q->front->next = del_node ->next;
   free(del_node);

}

int queue_Empty(queue *q)
{
    assert(q);
	if(q->front == q->rear)
	{
	   printf("队列为空\n");
	   return 1;
	}
	return 0;
}

void get_front(queue *q)
{
	if (q -> front == q -> rear)
	{
		return ;
	}

	printf("队头为：%d\n",q->front->next->_data);
    
}

void queue_print(queue *q)
{
	link_node p = q->front->next;
	printf("队列为：\n");
	if(!p)
	{
	   printf("队列为空\n");
	   return;
	}
	while(p)
	{
		printf("%d\n",p->_data);
		p = p->next;
	}
}

void queue_destroy(queue *q)
{
	while(q->rear)
	{
	   free(q);
	   q->front->next;
	}
}

 

test

 

#include"queue.h"
test()
{
    queue q;
	
	queue_init(&q);

	queue_en(&q , 1);
	queue_en(&q , 2);
	get_front(&q);

	queue_de(&q);
	get_front(&q);

	queue_en(&q , 3);
	queue_print(&q);
}

int main()
{
  test();
  system("pause");
  return 0;
}