国嵌数据结构学习之队列

队列的定义：

    队列是一种特殊的线性表

    队列仅在线性表的两端进行操作

        队头（Front):取出数据元素的一端

        队尾（Rear):插入数据元素的一端

    注意：队列不予许在中间部位进行操作

    应用：银行的取号排队

队列的性质：

    

队列的一些常用操作:

    创建队列

    销毁队列

    清空队列

    进队列

    出队列

    获取对头元素

    获取队列的长度

队列的顺序储存实现：

    

    实现代码：

    定义的头文件：

#ifndef _SEQQUEUE_H_
#define _SEQQUEUE_H_
#include "SeqList.h"

typedef void SeqQueue;

SeqQueue *SeqQueue_Create(int capacity);

void SeqQueue_Destroy(SeqQueue * queue);

void SeqQueue_Clear(SeqQueue *queue);

int SeqQueue_Append(SeqQueue *queue, void *item);

void *SeqQueue_Retrieve(SeqQueue *queue);

void *SeqQueue_Header(SeqQueue *queue);

int SeqQueue_Length(SeqQueue *queue);

int SeqQueue_Capacity(SeqQueue *queue);

#endif

 实现的c文件:

    

#include "SeqQueue.h"

//创建一个队列 
SeqQueue *SeqQueue_Create(int capacity)
{
    return SeqList_Create(capacity);    
}
//销毁一个队列 
void SeqQueue_Destroy(SeqQueue *queue)
{
    SeqList_Destory(queue);
}
//清空一个队列 
void SeqQueue_Clear(SeqQueue *queue)
{
    SeqList_Clear(queue);    
} 
//往队列中插入元素（尾部） 
int SeqQueue_Append(SeqQueue *queue, void *item)
{
    return SeqList_Insert(queue, item, SeqList_Length(queue));
}
//弹出队列的元素(头部) 
void *SeqQueue_Retrieve(SeqQueue *queue)
{
    SeqList_Delete(queue, 0);    
} 
//得到队列的头部元素 
void *SeqQueue_Header(SeqQueue *queue)
{
    return SeqList_Get(queue, 0);    
}
//得到队列的长度 
int SeqQueue_Length(SeqQueue *queue)
{
    return SeqList_Length(queue);    
}
//得到队列的容量
int SeqQueue_Capacity(SeqQueue *queue)
{
    return SeqList_Capacity(queue);    
} 

测试代码：

    

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

int main(int argc, char *argv[]) 
{
    SeqQueue* queue = SeqQueue_Create(20);
    int a[10] = {0};
    int i = 0;
    int x = 0;
    SeqQueue_Append(queue, (int*)&x);
    for(i=0; i<10; i++)
    {
        a[i] = i ;
        SeqQueue_Append(queue, a + i);
    }
    
    printf("Header: %d\n", *(int*)SeqQueue_Header(queue));
    printf("Length: %d\n", SeqQueue_Length(queue));
    printf("Capacity: %d\n", SeqQueue_Capacity(queue));
    
    while( SeqQueue_Length(queue) > 0 )
    {
        printf("Retrieve: %d\n", *(int*)SeqQueue_Retrieve(queue));
    }
    
    SeqQueue_Destroy(queue);
    getchar();
    
	return 0;
}

栈的链式存储实现;

    栈的链式存储结构:

    

    定义的头文件：

    

#ifndef _LINKQUEUE_H_
#define _LINKQUEUE_H_

#include "Linklist.h"
#include <stdlib.h>

typedef void LinkQueue;

LinkQueue *LinkQueue_Create();

void LinkQueue_Destroy(LinkQueue *queue);

void LinkQueue_Clear(LinkQueue *queue);

int LinkQueue_Append(LinkQueue *queue, void *item);

void* LinkQueue_Retrieve(LinkQueue* queue);

void* LinkQueue_Header(LinkQueue* queue);

int LinkQueue_Length(LinkQueue* queue); 


#endif 

实现的c文件：

    

#include "LinkQueue.h"

typedef struct _tag_LinkQueueNode LinkQueueNode;

struct _tag_LinkQueueNode
{
   LinkListNode header;
   void *item;      
};

//创建队列的头节点 
LinkQueue *LinkQueue_Create()
{
    return LinkList_Create();   
}
//销毁一个队列 
void LinkQueue_Destroy(LinkQueue *queue)
{
    //先清空 
    LinkQueue_Clear(queue);
    //后释放 
    LinkList_Destory(queue);
}
//清空一个队列 
void LinkQueue_Clear(LinkQueue *queue)
{
    while(LinkQueue_Length(queue) > 0 )
    {
        LinkList_Clear(queue);
    }
        
}
//进入队列
int LinkQueue_Append(LinkQueue *queue, void *item)
{
    
    int ret = 0;
    //申请一个节点空间
    LinkQueueNode *node =  (LinkQueueNode *)malloc(sizeof(LinkQueueNode));
    //合法性检测 
    if (node != NULL && item != NULL)
    {
        
        node->item = item; 
        //从尾部插入 
        ret = LinkList_Insert(queue, (LinkListNode*)node, LinkQueue_Length(queue));   
    }
    else 
    {
        free(node);    
    }
    
    return ret; 
} 
//出队列 
void* LinkQueue_Retrieve(LinkQueue* queue)
{
    //从头部删除 
    LinkQueueNode * node = (LinkQueueNode*)LinkList_Delete(queue,0);
    void* ret = NULL;
    if (node != NULL)
    {
        ret = node->item;
        free(node);    
    }
    
    return ret;
}  


//得到队列头部元素 
void* LinkQueue_Header(LinkQueue* queue)
{
    LinkQueueNode * node = (LinkQueueNode*)LinkList_Get(queue, 0);
    void *ret = NULL;
    
    if (node != NULL)
    {
        ret = node->item;
    }
    
    return ret;
} 
//得到队列长度 
int LinkQueue_Length(LinkQueue* queue)
{
    return LinkList_Length(queue);    
} 

    测试代码:

    

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

int main(int argc, char *argv[]) 
{
    LinkQueue* queue = LinkQueue_Create();
    int a[10] = {0};
    int i = 0;
    for(i=0; i<10; i++)
    {
        a[i] = i + 1;
        LinkQueue_Append(queue, a + i);
    }
    
    printf("Header: %d\n", *(int*)LinkQueue_Header(queue));
    printf("Length: %d\n", LinkQueue_Length(queue));
    
    while( LinkQueue_Length(queue) > 0 )
    {
        printf("Retrieve: %d\n", *(int*)LinkQueue_Retrieve(queue));
    }
    
    LinkQueue_Destroy(queue);
    getchar();
    
	return 0;
}