環形隊列實現原理
發表於2011/7/9 9:28:55 12945人閱讀
分類： Linux系統開發
環形隊列是在實際編程極為有用的數據結構,它有如下特點。
它是一個首尾相連的FIFO的數據結構，采用數組的線性空間,數據組織簡單。能很快知道隊列是否滿為空。能以很快速度的來存取數據。
因為有簡單高效的原因，甚至在硬件都實現了環形隊列.
環形隊列廣泛用於網絡數據收發，和不同程序間數據交換（比如內核與應用程序大量交換數據,從硬件接收大量數據）均使用了環形隊列.
一.環形隊列實現原理
------------------------------------------------------------
內存上沒有環形的結構，因此環形隊列實上是數組的線性空間來實現。那當數據到了尾部如何處理呢？它將轉回到0位置來處理。這個的轉回是通過取模操作來執行的。
因此環列隊列的是邏輯上將數組元素q[0]與q[MAXN-1]連接，形成一個存放隊列的環形空間。
為了方便讀寫，還要用數組下標來指明隊列的讀寫位置。head/tail.其中head指向可以讀的位置，tail指向可以寫的位置。
環形隊列的關鍵是判斷隊列為空，還是為滿。當tail追上head時，隊列為滿時，當head追上tail時，隊列為空。但如何知道誰追上誰。還需要一些輔助的手段來判斷.
如何判斷環形隊列為空，為滿有兩種判斷方法。
一.是附加一個標志位tag
當head趕上tail，隊列空，則令tag=0,
當tail趕上head，隊列滿，則令tag=1,
當tail趕上head，隊列滿，則令tag=1,
二.限制tail趕上head，即隊尾結點與隊首結點之間至少留有一個元素的空間。
隊列空： head==tail
隊列滿： (tail+1)% MAXN ==head
隊列滿： (tail+1)% MAXN ==head
二.附加標志實現算法
-------------------------------------------------------------
采用第一個環形隊列有如下結構
typedef struct ringq{
int head; /* 頭部，出隊列方向*/
int tail; /* 尾部，入隊列方向*/
int tag ;
int size ; /* 隊列總尺寸 */
int space[RINGQ_MAX]; /* 隊列空間 */
}RINGQ;
初始化狀態:
q->head = q->tail = q->tag = 0;
隊列為空:(
q->head == q->tail) && (q->tag == 0)
隊列為滿
: ((q->head == q->tail) && (q->tag == 1))
入隊操作:如隊列不滿，則寫入
q->tail = (q->tail + 1) % q->size ;
出隊操作：如果隊列不空，則從head處讀出。
出隊操作：如果隊列不空，則從head處讀出。
下一個可讀的位置在
q->head = (q->head + 1) % q->size
完整代碼
頭文件ringq.h
#ifndef __RINGQ_H__
#define __RINGQ_H__
#ifdef __cplusplus
extern "C" {
#endif
#define QUEUE_MAX 20
typedef struct ringq{
int head; /* 頭部，出隊列方向*/
int tail; /* 尾部，入隊列方向*/
int tag ; /* 為空還是為滿的標志位*/
int size ; /* 隊列總尺寸 */
int space[QUEUE_MAX]; /* 隊列空間 */
}RINGQ;
/*
第一種設計方法:
當head == tail 時，tag = 0 為空，等於 = 1 為滿。
*/
extern int ringq_init(RINGQ * p_queue);
extern int ringq_free(RINGQ * p_queue);
/* 加入數據到隊列 */
extern int ringq_push(RINGQ * p_queue,int data);
/* 從隊列取數據 */
extern int ringq_poll(RINGQ * p_queue,int *p_data);
#define ringq_is_empty(q) ( (q->head == q->tail) && (q->tag == 0))
#define ringq_is_full(q) ( (q->head == q->tail) && (q->tag == 1))
#define print_ringq(q) printf("ring head %d,tail %d,tag %d\n", q->head,q->tail,q->tag);
#ifdef __cplusplus
}
#endif
#endif /* __RINGQ_H__ */
實現代碼 ringq.c
#include <stdio.h>
#include "ringq.h"
int ringq_init(RINGQ * p_queue)
{
p_queue->size = QUEUE_MAX ;
p_queue->head = 0;
p_queue->tail = 0;
p_queue->tag = 0;
return 0;
}
int ringq_free(RINGQ * p_queue)
{
return 0;
}
int ringq_push(RINGQ * p_queue,int data)
{
print_ringq(p_queue);
if(ringq_is_full(p_queue))
{
printf("ringq is full\n");
return -1;
}
p_queue->space[p_queue->tail] = data;
p_queue->tail = (p_queue->tail + 1) % p_queue->size ;
/* 這個時候一定隊列滿了*/
if(p_queue->tail == p_queue->head)
{
p_queue->tag = 1;
}
return p_queue->tag ;
}
int ringq_poll(RINGQ * p_queue,int * p_data)
{
print_ringq(p_queue);
if(ringq_is_empty(p_queue))
{
printf("ringq is empty\n");
return -1;
}
*p_data = p_queue->space[p_queue->head];
p_queue->head = (p_queue->head + 1) % p_queue->size ;
/* 這個時候一定隊列空了*/
if(p_queue->tail == p_queue->head)
{
p_queue->tag = 0;
}
return p_queue->tag ;
}
測試代碼
/* 測試第一種環形隊列*/
void test5()
{
RINGQ rq, * p_queue;
int i,data;
p_queue = &rq;
ringq_init(p_queue);
for(i=0; i < QUEUE_MAX +2 ; i++)
{
ringq_push(p_queue,i+1);
}
if(ringq_poll(p_queue,&data)>=0)
PRINT_INT(data);
if(ringq_poll(p_queue,&data)>=0)
PRINT_INT(data);
if(ringq_poll(p_queue,&data)>=0)
PRINT_INT(data);
if(ringq_poll(p_queue,&data)>=0)
PRINT_INT(data);
if(ringq_poll(p_queue,&data)>=0)
PRINT_INT(data);
if(ringq_poll(p_queue,&data)>=0)
PRINT_INT(data);
ringq_free(p_queue);
}
/* 測試第一種環形隊列,更加復雜的情況*/
void test6()
{
RINGQ rq, * p_queue;
int i,data;
p_queue = &rq;
ringq_init(p_queue);
ringq_push(p_queue,1);
ringq_push(p_queue,2);
if(ringq_poll(p_queue,&data)>=0)
PRINT_INT(data);
if(ringq_poll(p_queue,&data)>=0)
PRINT_INT(data);
if(ringq_poll(p_queue,&data)>=0)
PRINT_INT(data);
if(ringq_poll(p_queue,&data)>=0)
PRINT_INT(data);
ringq_push(p_queue,3);
ringq_push(p_queue,4);
ringq_push(p_queue,5);
if(ringq_poll(p_queue,&data)>=0)
PRINT_INT(data);
if(ringq_poll(p_queue,&data)>=0)
PRINT_INT(data);
ringq_push(p_queue,6);
if(ringq_poll(p_queue,&data)>=0)
PRINT_INT(data);
if(ringq_poll(p_queue,&data)>=0)
PRINT_INT(data);
ringq_free(p_queue);
}
三.預留空間環境隊列
-------------------------------------------------------------------
不采用tag,只留一個空間
初始化狀態:
q->head = q->tail = q->tag = 0;
隊列為空:(
q->head == q->tail)
隊列為滿
: (((q->tail+1)%q->size) == q->head )
入隊操作:如隊列不滿，則寫入
q->tail = (q->tail + 1) % q->size ;
出隊操作：如果隊列不空，則從head處讀出。
出隊操作：如果隊列不空，則從head處讀出。
下一個可讀的位置在
q->head = (q->head + 1) % q->size
頭文件
ringq.h
#ifndef __RINGQ_H__
#define __RINGQ_H__
#ifdef __cplusplus
extern "C" {
#endif
#define RINGQ_MAX 20
typedef struct ringq{
int head; /* 頭部，出隊列方向*/
int tail; /* 尾部，入隊列方向*/
int size ; /* 隊列總尺寸 */
int space[RINGQ_MAX]; /* 隊列空間 */
}RINGQ;
/*
取消tag .限制讀與寫之間至少要留一個空間
隊列空 head == tail .
隊列滿是 (tail+1)%MAX == head
初始化是head = tail = 0;
*/
extern int ringq_init(RINGQ * p_ringq);
extern int ringq_free(RINGQ * p_ringq);
extern int ringq_push(RINGQ * p_ringq,int data);
extern int ringq_poll(RINGQ * p_ringq,int * p_data);
#define ringq_is_empty(q) (q->head == q->tail)
#define ringq_is_full(q) (((q->tail+1)%q->size) == q->head )
#define print_ringq2(q,d) printf("ring head %d,tail %d,data %d\n", q->head,q->tail,d);
#ifdef __cplusplus
}
#endif
#endif /* __QUEUE_H__ */
實現代碼ringq.c
#include <stdio.h>
#include "ringq.h"
int ringq_init(RINGQ * p_ringq)
{
p_ringq->size = RINGQ_MAX;
p_ringq->head = 0;
p_ringq->tail = 0;
return p_ringq->size;
}
int ringq_free(RINGQ * p_ringq)
{
return 0;
}
/* 往隊列加入數據 */
int ringq_push(RINGQ * p_ringq,int data)
{
print_ringq(p_ringq,data);
if(ringq_is_full(p_ringq))
{
printf("ringq is full,data %d\n",data);
return -1;
}
p_ringq->space[p_ringq->tail] = data;
p_ringq->tail = (p_ringq->tail + 1) % p_ringq->size ;
return p_ringq->tail ;
}
int ringq_poll(RINGQ * p_ringq,int * p_data)
{
print_ringq(p_ringq,-1);
if(ringq_is_empty(p_ringq))
{
printf("ringq is empty\n");
return -1;
}
*p_data = p_ringq->space[p_ringq->head];
p_ringq->head = (p_ringq->head + 1) % p_ringq->size ;
return p_ringq->head;
}
作者：Andrew Huang bluedrum@163.com