队列-适用于所有数据类型

最新推荐文章于 2024-04-25 12:18:13 发布

inintrovert

最新推荐文章于 2024-04-25 12:18:13 发布

阅读量104

点赞数

文章标签： c语言 c++ 数据结构

本文链接：https://blog.csdn.net/inintrovert/article/details/130660813

版权

1，头文件

/**
  ******************************************************************************
  * 版权所有： 
  * 文件名:   queue.c 
  * 作者：    zwy
  * 创建日期: 2023.05.13
  * 描述： 	此文档提供了队列的基本操作，可以适用于各种数据类型。
  * 
  ******************************************************************************
  */
#ifndef _QUEUE_H
#define _QUEUE_H

	
#include "stdio.h"
#include "stdlib.h"
#include "stdbool.h"
#include "string.h"

struct queue_record
{
    unsigned short capacity;            //队列能够容纳成员的数目
    unsigned short front;               //循环队列的头部
    unsigned short rear;                //循环队列的尾部
    unsigned short counter;             //循环队列中当前成员个数
    unsigned short max_iterm_size;      //循环队列单个成员占用字节数
    unsigned char *buf;                 //队列数据存放区
};

typedef struct queue_record  queue_t;

enum
{
	QUEUE_OP_SUCCESS = 0,          //操作成功
	QUEUE_OP_FAIL = (-1),          //操作失败
	QUEUE_OP_ERR_NO_MEM = (-2),    //队列已满
	QUEUE_OP_ERR_EMPTY = (-3),     //队列已空
};

int queue_init(queue_t * p_queue, unsigned short maxelements, unsigned char *buf, unsigned short max_iterm_size);
int queue_enqueue(queue_t * p_queue, const unsigned char *buf, unsigned short buf_size);
int queue_dequeue(queue_t * p_queue, unsigned char *buf, unsigned short buf_size);
bool queue_is_empty(queue_t * p_queue);
bool queue_is_full(queue_t * p_queue); 
void queue_make_empty(queue_t * p_queue);
#endif

2，源文件

/**
  ******************************************************************************
  * 版权所有： 
  * 文件名:   queue.c 
  * 作者：    zwy
  * 创建日期: 2023.05.13
  * 描述： 	此文档提供了队列的基本操作，可以适用于各种数据类型。
  * 
  ******************************************************************************
  */
#include "queue.h"

/******************************************************************************
 * 函数名:	succ 
 * 描述: 
 *            -队列索引值往后移一位
 * 输入参数: 
 * 输出参数: 
 * 返回值: 
 * 
 * 作者: 
 * 创建日期:
 * 
 *------------------------
 * 修改人:
 * 修改日期:
 ******************************************************************************/
static unsigned short succ( unsigned short value, queue_t * q )
{
	if ( ++value == q->capacity )
	{
		value = 0;
	}
	return value;
}

/******************************************************************************
 * 函数名:	queue_is_empty 
 * 描述: 
 *            -判断队列是否已空
 * 输入参数: 
 * 输出参数: 
 * 返回值: 
 * 
 * 作者: 
 * 创建日期:
 * 
 *------------------------
 * 修改人:
 * 修改日期:
 ******************************************************************************/
bool queue_is_empty(queue_t * q)
{
	return q->counter == 0;
}

/******************************************************************************
 * 函数名:	queue_is_full 
 * 描述: 
 *            -判断队列是否已满
 * 输入参数: 
 * 输出参数: 
 * 返回值: 
 * 
 * 作者: 
 * 创建日期:
 * 
 *------------------------
 * 修改人:
 * 修改日期:
 ******************************************************************************/
bool queue_is_full(queue_t * q)
{
	return q->counter == q->capacity;
}

/******************************************************************************
 * 函数名:	queue_init 
 * 描述: 
 *            -队列清空
 * 输入参数: 
 * 输出参数: 
 * 返回值: 
 * 
 * 作者: 
 * 创建日期:
 * 
 *------------------------
 * 修改人:
 * 修改日期:
 ******************************************************************************/
void queue_make_empty( queue_t * q )
{
	q->counter = 0;
	q->front = 1;
	q->rear = 0;
}

/******************************************************************************
 * 函数名:	queue_init 
 * 描述: 
 *            -队列初始化
 * 输入参数: 
 *  			p_queue-队列指针
 * 				maxelements-队列能够容纳成员的数目
 * 				buf-队列数据存放位置
 * 				max_iterm_size-队列单个成员占用字节数
 * 输出参数: 
 * 返回值: 		返回操作结果
 * 				QUEUE_OP_SUCCESS-操作成功
 * 				QUEUE_OP_FAIL-操作失败
 * 
 * 作者: 
 * 创建日期:
 * 
 *------------------------
 * 修改人:
 * 修改日期:
 ******************************************************************************/
int queue_init(queue_t *p_queue, unsigned short maxelements, unsigned char *buf, unsigned short max_iterm_size)
{
	if(p_queue == NULL || buf == NULL || maxelements < 2 || max_iterm_size < 1)
	{
		return QUEUE_OP_FAIL;
	}
	p_queue->buf = buf;
	p_queue->capacity = maxelements;
	p_queue->max_iterm_size = max_iterm_size;
	queue_make_empty(p_queue);

	return QUEUE_OP_SUCCESS;
}

/******************************************************************************
 * 函数名:	queue_enqueue 
 * 描述: 
 *            -队列入列操作
 * 输入参数: 
 *  			p_queue-队列指针
 * 				buf-入列数据
 * 				buf_size-入列数据字节数，需小于type_size
 * 输出参数: 
 * 返回值: 		返回操作结果
 * 				QUEUE_OP_SUCCESS-操作成功
 *				QUEUE_OP_FAIL-操作失败，参数有误
 * 				QUEUE_OP_ERR_NO_MEM-操作失败，队列已满
 * 
 * 作者: 
 * 创建日期:
 * 
 *------------------------
 * 修改人:
 * 修改日期:
 ******************************************************************************/
int queue_enqueue(queue_t *p_queue, const unsigned char *buf, unsigned short buf_size)
{
	if(p_queue == NULL || buf == NULL || buf_size > p_queue->max_iterm_size)
	{
		return QUEUE_OP_FAIL;
	}	

	if(queue_is_full( p_queue ))
	{
		return QUEUE_OP_ERR_NO_MEM;
	}

	p_queue->counter++;
	p_queue->rear = succ( p_queue->rear, p_queue );	
	memcpy(p_queue->buf + p_queue->rear * p_queue->max_iterm_size, buf, p_queue->max_iterm_size);

	return QUEUE_OP_SUCCESS;
}

/******************************************************************************
 * 函数名:	queue_dequeue 
 * 描述: 
 *            -队列出列操作
 * 输入参数: 
 * 				p_queue-队列指针
 * 				buf_size-出列数据字节数，小于type_size
 * 输出参数: 
 *				buf-出列数据
 * 返回值: 
 * 				QUEUE_OP_SUCCESS-操作成功
 *				QUEUE_OP_FAIL-操作失败，参数有误 
 * 				QUEUE_OP_ERR_EMPTY-操作失败，队列已空
 * 作者: 
 * 创建日期:
 * 
 *------------------------
 * 修改人:
 * 修改日期:
 ******************************************************************************/
int queue_dequeue(queue_t * p_queue, unsigned char *buf, unsigned short buf_size)
{
	if(p_queue == NULL || buf == NULL || buf_size > p_queue->max_iterm_size)
	{
		return QUEUE_OP_FAIL;
	}	

	if (queue_is_empty( p_queue ))
	{
		return QUEUE_OP_ERR_EMPTY;
	}	

	memcpy(buf, p_queue->buf + p_queue->front * p_queue->max_iterm_size, buf_size);
	p_queue->counter--;
	p_queue->front = succ( p_queue->front, p_queue );	

	return QUEUE_OP_SUCCESS;	
}

3，测试文件

#include "queue.h"
#include "stdio.h"
#include <string.h>

//测试结构体1
typedef struct 
{
    int a;
    int b;
    int c;
}test_1_t;

//测试结构体2
typedef struct 
{
    short d;
    char e;
    int f;
}test_2_t;

//队列1缓存区数组大小
#define TEST_1_BUF_SIZE  20
//队列2缓存区数组大小
#define TEST_2_BUF_SIZE  10

//队列1缓存区
test_1_t m_test_1_buf[TEST_1_BUF_SIZE];

//队列2缓存区
test_2_t m_test_2_buf[TEST_2_BUF_SIZE];

//队列1
queue_t m_test_1_queue;
//队列2
queue_t m_test_2_queue;

int main()
{
    //队列初始化
    queue_init(&m_test_1_queue, TEST_1_BUF_SIZE, (unsigned char *)&m_test_1_buf, sizeof(test_1_t));
    queue_init(&m_test_2_queue, TEST_2_BUF_SIZE, (unsigned char *)&m_test_2_buf, sizeof(test_2_t));
    while(1)
    {
        char ch = getchar();
        unsigned char key_code = 0;
        switch(ch)
        {   
            case '1': 
            {
                //入列操作
                test_1_t dat = {1,2,3};
                int ret = queue_enqueue(&m_test_1_queue, (unsigned char *)&dat, sizeof(test_1_t));  
                if(ret == QUEUE_OP_SUCCESS)
                {
                    printf("1 enqueue ok!\n");
                }
                else
                {
                    printf("1 enqueue fail..%d\n", ret);
                }
                break;
            }   
            case '2': 
            {
                 //入列操作
                test_2_t dat = {4,5,6};
                int ret = queue_enqueue(&m_test_2_queue, (unsigned char *)&dat, sizeof(test_2_t));  
                if(ret == QUEUE_OP_SUCCESS)
                {
                    printf("2 enqueue ok!\n");
                }
                else
                {
                    printf("2 enqueue fail..%d\n", ret);
                }
                break;
            }               
            case 'd': 
            {
                 //出列操作
                test_1_t dat1;
                int ret = queue_dequeue(&m_test_1_queue, (unsigned char *)&dat1, sizeof(test_1_t));
                if(ret == QUEUE_OP_SUCCESS)
                {
                    printf("1 dequeue ok!\n");
                }
                else
                {
                    printf("1 dequeue fail..%d\n", ret);
                }                
                break;
            }   
            case 'f': 
            {
                //出列操作
                test_2_t dat2;
                int ret = queue_dequeue(&m_test_2_queue, (unsigned char *)&dat2, sizeof(test_2_t));
                if(ret == QUEUE_OP_SUCCESS)
                {
                    printf("2 dequeue ok!\n");
                }
                else
                {
                    printf("2 dequeue fail..%d\n", ret);
                }              
                break;
            }                                                
        }

        if(ch == 'b')
        {
            break;
        }

    }

    printf("hahahhah\n");
    return 0;
}