循环队列详解-优快云博客

循环队列

1、数据结构

typedef struct {
  uint8 *pData;
  uint16 wIdx;
  uint16 rIdx;
  uint16 len;
} cirbuf_t;

2、函数实现

2.1、队列初始化。设置队列的内存首地址以及队列的大小。

void cirBufInit(cirbuf_t *pCirBuf, uint8 *pAddr, uint16 len)
{
    pCirBuf->pData = pAddr;
    pCirBuf->wIdx = 0;
    pCirBuf->rIdx = 0;
    pCirBuf->len = len;
}

2.2、队列空判断。

uint8 cirBufIsEmpty(cirbuf_t *pCirBuf)
{
    return (pCirBuf->rIdx == pCirBuf->wIdx) ? 0x01 : 0x00;
}

2.3、队列满判断。

uint8 cirBufIsFull(cirbuf_t *pCirBuf)
{
    return (pCirBuf->rIdx == (pCirBuf->wIdx + 1) % pCirBuf->len) ? 0x01 : 0x00;
}

2.4、获取队列元素个数。

uint16 cirBufItemLen(cirbuf_t *pCirBuf)
{
    return (pCirBuf->wIdx + pCirBuf->len - pCirBuf->rIdx) % pCirBuf->len;
}

2.5、获取队列剩余空间。

uint16 cirBufFreeLen(cirbuf_t *pCirBuf)
{
    return (pCirBuf->rIdx + pCirBuf->len - 1 - pCirBuf->wIdx) % pCirBuf->len;
}

2.6、向队列中写入len个字节的数据。返回实际写入的字节数。

uint16 cirBufWrite(cirbuf_t *pCirBuf, uint8 *pData, uint16 len)
{
    uint16 cnt = 0;

    if ((pData != NULL) && (len > 0)) {
        for (cnt = 0; cnt < len; cnt++) {
            /* circular buffer is full. */
            if (pCirBuf->rIdx == (pCirBuf->wIdx + 1) % pCirBuf->len) {
                break;
            }
	    else {
                pCirBuf->pData[pCirBuf->wIdx] = *pData++;
                pCirBuf->wIdx = (pCirBuf->wIdx + 1) % pCirBuf->len;
            }
        }
    }
    
    return cnt;
}

2.7、向队列中循环写入len个字节的数据。返回实际写入的字节数。

uint16 cirBufWrapWrite(cirbuf_t *pCirBuf, uint8 *pData, uint16 len)
{
    uint16 cnt = 0;

    if ((pData != NULL) && (len > 0)) {
        for (cnt = 0; cnt < len; cnt++) {
            /* circular buffer is full. */
            if (pCirBuf->rIdx == (pCirBuf->wIdx + 1) % pCirBuf->len) {
            	/*pCirBuf->pData[pCirBuf->rIdx] = 0x00;*/ /* Test */
                pCirBuf->rIdx = (pCirBuf->rIdx + 1) % pCirBuf->len;
            }
            pCirBuf->pData[pCirBuf->wIdx] = *pData++;
            pCirBuf->wIdx = (pCirBuf->wIdx + 1) % pCirBuf->len;
        }
    }
    
    return cnt;
}

2.8、从队列中读取len个字节的数据。返回实际读取的字节数。

uint16 cirBufRead(cirbuf_t *pCirBuf, uint8 *pData, uint16 len)
{
    uint16 cnt = 0;
    
    if ((pData != NULL) && (len > 0)) {
        for (cnt = 0; cnt < len; cnt++) {
            /* circular buffer is empty. */
            if (pCirBuf->rIdx == pCirBuf->wIdx) {
                break;
            }
            else {
                *pData++ = pCirBuf->pData[pCirBuf->rIdx];
                /*pCirBuf->pData[pCirBuf->rIdx] = 0x00;*/ /* Test */
                pCirBuf->rIdx = (pCirBuf->rIdx + 1) % pCirBuf->len;
            }
        }
    }

    return cnt;
}

3、解释说明

3.1、如何循环队列的“空”和“满”的判断？

在队列初始化时，会设置队列的大小，以及队列的读写位置标志。

当读写位置标志相等时，表示队列空；

当写的位置标志相比读的位置标志循环大1时，表示队列满。

所以，循环队列，能够存储的数据个数，最多比设置的数据个数小1。

3.2、cirBufWrite()与cirBufWrapWrite()的区别？

cirBufWrite()：该函数向队列中写入数据之前先判断队列是否满，若满，则退出不再写入数据；

cirBufWrapWrite()：该函数向队列中写入数据之前先判断队列是否满，若满，则继续循环写入数据，这将会挤出队列中最早写入但没有读出的数据。

4、使用例程

cirbuf_t testCirBuf;
uint8 Array[10] = {0x00};
uint8 writeData[10] = {0x00};

int main(void)
{
    uint16 ret = 0;
    uint16 temp = 3;
	
    cirBufInit(&testCirBuf, Array, sizeof(Array));
	
    for (int i=0; i<10; i++)
    {
        for (int j=0; j<10; j++) {
	    writeData[j] = rand();
        }
	
        ret = cirBufWrite(&testCirBuf, writeData, temp);
        ret = cirBufWrapWrite(&testCirBuf, writeData, temp);
        ret = cirBufRead(&testCirBuf, writeData, temp);
    }
    return 0;
}