queue基本概念
队列是一种特殊的线性表
队列仅在线性表的两端进行操作
队头(Front):取出数据元素的一端
队尾(Rear):插入数据元素的一端
队列不允许在中间部位进行操作!
队列规则:FIFO(先进先出)
由前篇已经介绍线性表,这边就直接拿上次的代码来模拟:
seqlist.h
#ifndef __MY_SEQLIST_H__
#define __MY_SEQLIST_H__
typedef void SeqList;
typedef void SeqListNode;
SeqList* SeqList_Create(int capacity);
void SeqList_Destroy(SeqList* list);
void SeqList_Clear(SeqList* list);
int SeqList_Length(SeqList* list);
int SeqList_Capacity(SeqList* list);
int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);
SeqListNode* SeqList_Get(SeqList* list, int pos);
SeqListNode* SeqList_Delete(SeqList* list, int pos);
#endif //__MY_SEQLIST_H__
sqelist.c
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "seqlist.h"
//在结构体中套1级指针
//
typedef struct _tag_SeqList
{
int length;
int capacity;
unsigned int *node; //int* node[]
}TSeqList;
SeqList* SeqList_Create(int capacity)
{
int ret = 0;
TSeqList *tmp = NULL;
tmp = (TSeqList *)malloc(sizeof(TSeqList));
if (tmp == NULL)
{
ret = -1;
printf("func SeqList_Create() err:%d \n", ret);
return NULL;
}
memset(tmp, 0, sizeof(TSeqList));
//根据capacity 的大小分配节点的空间
tmp->node = (unsigned int *)malloc(sizeof(unsigned int *) * capacity);
if (tmp->node == NULL)
{
ret = -2;
printf("func SeqList_Create() err: malloc err %d \n", ret);
return NULL;
}
tmp->capacity = capacity;
tmp->length = 0;
return tmp;
}
void SeqList_Destroy(SeqList* list)
{
TSeqList *tlist = NULL;
if (list == NULL)
{
return ;
}
tlist = (TSeqList *)list;
if (tlist->node != NULL)
{
free(tlist->node);
}
free(tlist);
return ;
}
//清空链表 //回到初始化状态
void SeqList_Clear(SeqList* list)
{
TSeqList *tlist = NULL;
if (list == NULL)
{
return ;
}
tlist = (TSeqList *)list;
tlist->length = 0;
return ;
}
int SeqList_Length(SeqList* list)
{
TSeqList *tlist = NULL;
if (list == NULL)
{
return -1;
}
tlist = (TSeqList *)list;
return tlist->length;
}
int SeqList_Capacity(SeqList* list)
{
TSeqList *tlist = NULL;
if (list == NULL)
{
return -1;
}
tlist = (TSeqList *)list;
return tlist->capacity;
}
int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)
{
int i =0, ret = 0;
TSeqList *tlist = NULL;
if (list == NULL || node==NULL || pos<0)
{
ret = -1;
printf("fun SeqList_Insert() err:%d \n", ret);
return ret;
}
tlist = (TSeqList*)list;
//判断是不是满了
if (tlist->length >= tlist->capacity)
{
ret = -2;
printf("fun SeqList_Insert() (tlist->length >= tlist->capacity) err:%d \n", ret);
return ret;
}
//容错修正 6个长度 容量20;用户pos10位置插入..
if (pos>=tlist->length)
{
pos = tlist->length; //
}
//1 元素后移
for(i=tlist->length; i>pos; i--)
{
tlist->node[i] = tlist->node[i-1];
//a[7] = a[6]
}
// i = 3
// 2插入元素
tlist->node[pos] = (unsigned int )node;
tlist->length ++;
return 0;
}
SeqListNode* SeqList_Get(SeqList* list, int pos)
{
int i =0;
SeqListNode *ret = 0;
TSeqList *tlist = NULL;
if (list == NULL || pos<0)
{
printf("fun SeqList_Get() err:%d \n", ret);
return NULL;
}
tlist = (TSeqList*)list;
ret = (void *)tlist->node[pos];
return ret;
}
SeqListNode* SeqList_Delete(SeqList* list, int pos)
{
int i = 0;
SeqListNode *ret = 0;
TSeqList *tlist = NULL;
if (list == NULL || pos<0) //检查
{
printf("fun SeqList_Delete() err:%d \n", ret);
return NULL;
}
tlist = (TSeqList*)list;
ret = (SeqListNode *)tlist->node[pos]; //缓存pos的位置
for (i=pos+1; i<tlist->length; i++) //pos位置后面的元素前移
{
tlist->node[i-1] = tlist->node[i];
}
tlist->length --;
return ret;
}
seqQueue.h
#ifndef _MY_SEQQUEUE_H_
#define _MY_SEQQUEUE_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 //_MY_SEQQUEUE_H_
seqQueue.c
#include <stdlib.h>
#include <stdlib.h>
#include <string.h>
#include "seqlist.h"
#include "SeqQueue.h"
//初始化队列 相当于 初始化线性表
SeqQueue* SeqQueue_Create(int capacity)
{
return SeqList_Create(capacity);
}
//销毁队列 相当于 销毁线性表
void SeqQueue_Destroy(SeqQueue* queue)
{
SeqList_Destroy(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)
{
return (void*)SeqList_Delete(queue,0);
}
//获取队列的头部元素 相当于获取线性表头部元素
void* SeqQueue_Header(SeqQueue* queue)
{
return (void*)SeqList_Get(queue,0);
}
//获取队列的长度 相当于获取线性表长度
int SeqQueue_Length(SeqQueue* queue)
{
return SeqList_Length(queue);
}
//获取队列的容量 相当于获取线性表容量
int SeqQueue_Capacity(SeqQueue* queue)
{
return SeqList_Capacity(queue);
}
测试程序:main.c
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "seqlist.h"
#include "SeqQueue.h"
int main()
{
SeqQueue* queue= NULL;
int arr[10] = {'\0'};
int i = 0;
int tmp;
queue = SeqQueue_Create(10);
for(i = 0;i<5;i++)
{
arr[i] = i+1;
SeqQueue_Append(queue, &arr[i]);
}
printf("SeqQueue_Header:%d\n",*((int*)SeqQueue_Header(queue)));
printf("SeqQueue_Length:%d\n",SeqQueue_Length(queue));
printf("SeqQueue_Capacity:%d\n",SeqList_Capacity(queue));
while(SeqQueue_Length(queue)>0)
{
tmp = (*(int*)SeqQueue_Retrieve(queue));
printf("SeqQueue_Retrieve value:%d\n",tmp);
}
system("pause");
return 0;
}
队列的习题可以参考剑者offer里面的几道。
在本人博客剑指offer栏目有具体介绍