数据结构学习笔记(8.循环队列与链队列)

本节知识点：

1.队列的概念：

    a.队列也是一种特殊的线性表，队列仅在线性表的两端进行操作，队头：取出数据元素的一端、队尾：插入数据元素的一端！

    b.队列的性质：先进先出(FIFO)

     对于普通的链式队列和顺序队列来说，具体的实现方式跟链式栈和顺序栈一样，只不过无所谓哪边是队列头、哪边是队列尾。因为时间复杂度必然有一端为O(1)，另一端为O(N)！对于这样的复杂度，我们就应该想办法使它都降到O(1)，所以就引入了循环队列！

2.循环队列：

代码如下：

SeqQueue.c文件：

/************************************************************************************ 
文件名：SeqQueue.c
头文件：SeqQueue.h 
时间： 2014/03/31 
作者： Hao 
功能：可以复用的顺序循环队列  即入队列和出队列的时间复杂度都为O(1) 
************************************************************************************/
#include <stdio.h>
#include <malloc.h>
#include "SeqQueue.h"

typedef void* TSeqQueueNode;
typedef struct str_SeqQueue
{
	int capacity;
    int length;
    int front;
    int rear;
    TSeqQueueNode* node;
}TSeqQueue;

/************************************************************************************ 
函数名：   SeqQueue_Create
函数功能： 创建一个容量为capacity的循环队列 
参数：     int capacity 创建循环队列中成员的个数 即循环队列容量
返回值：   void* ret 如果返回NULL 说明创建循环队列失败
                     如果返回ret 说明创建循环队列成功  且ret为描述循环队列的结构体 
************************************************************************************/
SeqQueue* SeqQueue_Create(int capacity)
{
    TSeqQueue* ret = NULL;
    
    if( capacity >= 0 )
    {
        ret = (TSeqQueue*)malloc(sizeof(TSeqQueue) + sizeof(TSeqQueueNode) * capacity);   
	    if( ret != NULL )
	    {
	        ret->capacity = capacity;
	        ret->length = 0;
	        ret->front = 0;
	        ret->rear = 0;
	        ret->node = (TSeqQueueNode*)(ret + 1);
	    }
    }
    else
	{
		ret = NULL;
	} 
    return (SeqQueue*)ret;	
}

/************************************************************************************ 
函数名：   SeqQueue_Destroy
函数功能： 销毁循环队列   free开辟的内存 
参数：     void* list 描述循环队列结构体指针
返回值：   void 
************************************************************************************/
void SeqQueue_Destroy(SeqQueue* queue)
{
	free(queue);
}

/************************************************************************************ 
函数名：  SeqQueue_Clear
函数功能：清空循环队列  其实就是给length=0； front = 0   rear = 0;
函数参数：SeqQueue* queue 描述循环队列结构体指针
函数返回值：int ret  成功返回0
                     失败返回-1 
************************************************************************************/
int SeqQueue_Clear(SeqQueue* queue)
{
	int ret;
	TSeqQueue *Tqueue = (TSeqQueue* )queue;
	/*函数参数合法性检测*/
	if(NULL != Tqueue)
	{
		Tqueue->length = 0;
		Tqueue->front = 0;
		Tqueue->rear = 0;
		ret=0;
	} 
	else
		ret=-1;
	return ret;
}

/************************************************************************************ 
函数名：  SeqQueue_Length
函数功能：获得循环队列 现在的大小
函数参数：void* list 描述循环队列结构体指针
函数返回值：int ret  成功返回length
                     失败返回-1 
************************************************************************************/
int SeqQueue_Length(SeqQueue* queue)
{
	int ret;
	TSeqQueue *Tqueue = (SeqQueue* )queue;
	/*函数参数合法性检测*/
	if(NULL != Tqueue)
	{
		ret = Tqueue->length;
	} 
	else
		ret = -1;
	return ret;
}

/************************************************************************************
函数名：  SeqQueue_Capacity
函数功能：获得循环队列 的容量 
函数参数：void* list 描述循环队列结构体指针
函数返回值：int ret  成功返回capacity 
                     失败返回-1 
************************************************************************************/
int SeqQueue_Capacity(SeqQueue* queue)
{
	int ret;
	TSeqQueue *Tqueue = (SeqQueue* )queue;
	/*函数参数合法性检测*/
	if(NULL != Tqueue)
	{
		ret = Tqueue->capacity;
	} 
	else
		ret = -1;
	return ret;
}

/************************************************************************************
函数名：  SeqQueue_Push
函数功能：入队操作 
函数参数：SeqQueue* queue入队队列, void* data入队数据元素  
          这个队列是从尾部入队rear  从头部出队front  
函数返回值：int ret  成功返回 1 
                     失败返回 0
************************************************************************************/
int SeqQueue_Push(SeqQueue* queue, void* data)
{
	TSeqQueue* Tqueue = (TSeqQueue*)queue;
	int ret = (Tqueue != NULL) && (data != NULL); //安全性检测 
    ret = ret && (Tqueue->length + 1 <= Tqueue->capacity); //容量检测 
    if(ret)
	{
		Tqueue->node[Tqueue->rear] = data;
		Tqueue->rear = (Tqueue->rear + 1) % Tqueue->capacity;
		Tqueue->length++;
	} 
	
	return ret;  
}

/************************************************************************************
函数名：  SeqQueue_Pop
函数功能：出队操作 
函数参数：SeqQueue* queue出队队列  
          这个队列是从尾部入队rear  从头部出队front  
函数返回值：void* ret  成功返回 数据元素地址 
                       失败返回 NULL 
************************************************************************************/
void* SeqQueue_Pop(SeqQueue* queue)
{
	TSeqQueue* Tqueue = (TSeqQueue*)queue;
	void* ret = NULL;
	if((Tqueue != NULL) && (Tqueue->length > 0))
	{
		ret = (void*)(Tqueue->node[Tqueue->front]);
		Tqueue->front = (Tqueue->front + 1) % Tqueue->capacity;
		Tqueue->length--;
	}
	return ret;
}

/************************************************************************************
函数名：  SeqQueue_Top
函数功能：获得队尾元素地址 
函数参数：SeqQueue* queue出队队列  
          这个队列是从尾部入队rear  从头部出队front  
函数返回值：void* ret  成功返回 队尾数据元素地址 
                       失败返回 NULL 
************************************************************************************/
void* SeqQueue_Top(SeqQueue* queue)
{
	TSeqQueue* Tqueue = (TSeqQueue*)queue;
	void* ret = NULL;
	if((Tqueue != NULL) && (Tqueue->length > 0))
	{
		ret = (void*)(Tqueue->node[Tqueue->front]);
	}
	return ret;
}

SeqQueue.h文件：

#ifndef _SeqQueue_H_
#define _SeqQueue_H_

typedef void SeqQueue;

SeqQueue* SeqQueue_Create(int capacity);

void SeqQueue_Destroy(SeqQueue* queue);

int SeqQueue_Clear(SeqQueue* queue);

int SeqQueue_Push(SeqQueue* queue, void* data);

void* SeqQueue_Pop(SeqQueue* queue);

void* SeqQueue_Top(SeqQueue* queue);

int SeqQueue_Length(SeqQueue* queue);

int SeqQueue_Capacity(SeqQueue* queue);

#endif

main.c文件：

#include <stdio.h>
#include <stdlib.h>
#include "SeqQueue.h"


int main(int argc, char *argv[]) 
{
    SeqQueue* queue = SeqQueue_Create(6);
    int a[10] = {0};
    int i = 0;
    
    for(i=0; i<10; i++)
    {
        a[i] = i + 1;
        
        SeqQueue_Push(queue, a + i);
    }
    
    printf("Top: %d\n", *(int*)SeqQueue_Top(queue));
    printf("Length: %d\n", SeqQueue_Length(queue));
    printf("Capacity: %d\n", SeqQueue_Capacity(queue));
    
    while( SeqQueue_Length(queue) > 0 )
    {
        printf("Pop: %d\n", *(int*)SeqQueue_Pop(queue));
    }
    
    printf("\n");
    
    for(i=0; i<10; i++)
    {
        a[i] = i + 1;
        
        SeqQueue_Push(queue, a + i);
        printf("Pop: %d\n", *(int*)SeqQueue_Pop(queue));
    }
    
    SeqQueue_Destroy(queue);
    
	return 0;
}

注意：其实循环队列就是在一段内存空间中，使用front和rear变量夹住一端空间，使其成为顺序队列，并且入队列和出队列的时间复杂度都是O(1)

3.链式队列：

示例代码：

LinkQueue.c文件：

/*******************************************************************************************************
文件名：LinkQueue.c
头文件：LinkQueue.h 
时间： 2013/03/31
作者： Hao
功能:  可以复用 链式队列 
*******************************************************************************************************/
#include <stdio.h>
#include <malloc.h>
#include "LinkQueue.h"

typedef struct str_linkqueue
{
	LinkQueueNode* front;
	LinkQueueNode* rear;
	int length;
}link_queue;

/*******************************************************************************************************
函数名：  Creat_LinkQueueHead
函数功能：创建一个链式队列头 并给队列头分配空间
参数： void
返回值：ret 成功返回链表头地址  失败返回NULL 
*******************************************************************************************************/
LinkQueue* Creat_LinkQueueHead(void)
{
	link_queue* ret = NULL;
	ret = (link_queue* )malloc( sizeof(link_queue)*1 );
	if(NULL != ret) //malloc分配成功 
	{
		ret -> length = 0;
		ret -> front = NULL;
		ret -> rear = NULL; 
	}
	return (LinkQueue* )ret; 
}

/*******************************************************************************************************
函数名：  Get_Length
函数功能：获得链式队列的长度 
参数： LinkQueue* queue 描述队列的结构体 
返回值：ret 成功返回队列长度  失败返回0 
*******************************************************************************************************/
int Get_Length(LinkQueue* queue)
{
	int ret = 0;
	link_queue* lqueue = (link_queue* )queue;
	if( NULL != lqueue )
	{
		ret = lqueue -> length;
	}	
	return ret;
}

/*******************************************************************************************************
函数名：  LinkQueue_Push
函数功能：把数据data从队尾加入队列中 
参数： LinkQueue* queue 描述队列的结构体   void* data 要加入队列数据的地址 
返回值：ret 成功返回1  失败返回0 
*******************************************************************************************************/
int LinkQueue_Push(LinkQueue* queue, void* data)
{
	link_queue* lqueue = (link_queue* )queue;
	int ret = ((NULL != lqueue)&&(NULL != data));
	if(ret)
	{
		LinkQueueNode* node = (LinkQueueNode*)malloc(sizeof(LinkQueueNode));
		if(NULL != node)
		{
			node -> Queuedata = data;
			if(lqueue -> length == 0)
			{
				lqueue -> front = node;
				lqueue -> rear = node;
				node -> next = NULL;
			}
			else
			{
				lqueue -> rear -> next = node;
				lqueue -> rear = node;
				node -> next = NULL; 
			}
			lqueue -> length++;
		}
		
	}
	
	return ret;
} 

/*******************************************************************************************************
函数名：  LinkQueue_Pop
函数功能：把数据从队头取出 
参数： LinkQueue* queue 描述队列的结构体   
返回值：ret 成功返回取出数据地址  失败返回NULL 
*******************************************************************************************************/
void* LinkQueue_Pop(LinkQueue* queue)
{
	void* ret = NULL;
	LinkQueueNode* node = NULL; 
	link_queue* lqueue = (link_queue* )queue;
	
	if((NULL != lqueue)&&(lqueue->length > 0))
	{
		node = lqueue->front;
		lqueue->front = lqueue->front->next;
		lqueue->length--;
		ret = node->Queuedata;
		free(node);
		
		if(lqueue->length == 0)
		{
			lqueue->front = NULL; //其实理论上可以不给front赋值NULL的  
			lqueue->rear = NULL;
		}
	}
	return ret;
} 

/*******************************************************************************************************
函数名：  LinkQueue_Top
函数功能：获得队头数据地址 
参数： LinkQueue* queue 描述队列的结构体   
返回值：ret 成功返回取出数据地址  失败返回NULL 
*******************************************************************************************************/
void* LinkQueue_Top(LinkQueue* queue)
{
	void* ret = NULL;

	link_queue* lqueue = (link_queue* )queue;
	
	if((NULL != lqueue)&&(lqueue->length > 0))
	{
		ret = lqueue->front->Queuedata;

	}
	return ret;
} 

/*******************************************************************************************************
函数名：  Clean_LinkQueue
函数功能：清空队列 
参数： LinkQueue* queue 描述队列的结构体   
返回值：ret 成功返回1  失败返回0 
*******************************************************************************************************/
int Clean_LinkQueue(LinkQueue* queue)
{
	int ret = 0;
	void* temp = NULL;
	if(NULL != queue)
	{
		ret = 1;
		while(Get_Length(queue))
		{
			temp = LinkQueue_Pop(queue);
			if(NULL == temp)
			{
				ret = 0;
				break;
			}
		}
		
	}
	return ret;
}

/*******************************************************************************************************
函数名：  Destroy_LinkQueue
函数功能：清空队列并且销毁队列头 
参数： LinkQueue* queue 描述队列的结构体   
返回值：ret 成功返回1  失败返回0 
*******************************************************************************************************/
void Destroy_LinkQueue(LinkQueue* queue)
{
	Clean_LinkQueue(queue);
	free(queue);
}

LinkQueue.h 文件：

#ifndef __LinkQueue_H__
#define __LinkQueue_H__

typedef void LinkQueue;  //这个是为了 封装方便 
typedef struct Str_LinkQueue LinkQueueNode;  //这个结构体是链表的真身 
struct Str_LinkQueue   
{                     
	LinkQueueNode* next;
	void* Queuedata;
};

LinkQueue* Creat_LinkQueueHead(void);

void Destroy_LinkQueue(LinkQueue* queue);

int Get_Length(LinkQueue* queue);

int Clean_LinkQueue(LinkQueue* queue);

int LinkQueue_Push(LinkQueue* queue, void* data);

void* LinkQueue_Pop(LinkQueue* queue);

void* LinkQueue_Top(LinkQueue* queue); 
 
#endif

main.c 文件：

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

int main()
{
	LinkQueue* queue = Creat_LinkQueueHead();
    int a[10] = {0};
    int i = 0;
    
    for(i=0; i<10; i++)
    {
        a[i] = i + 1;
        
        LinkQueue_Push(queue, a + i);
    }
    
    printf("Pop: %d\n", *(int*)LinkQueue_Pop(queue));
    printf("Top: %d\n", *(int*)LinkQueue_Top(queue));
    printf("Length: %d\n", Get_Length(queue));
    
    //Clean_LinkQueue(queue);
    
    while( Get_Length(queue) > 0 )
    {
        printf("Pop: %d\n", *(int*)LinkQueue_Pop(queue));
    }
    
    Destroy_LinkQueue(queue);
	return 0;
} 

注意：链队列，无非就是定义了两个指针，分别指向队列头和队列尾，这样找到队头和队尾的时间复杂度就是O(1)