【C基础】队列的实现

队列模块的接口：

#include <stdlib.h>

#define QUEUE_TYPE int  /* 队列元素的类型 */

void create_queue( size_t size ); /* 创建一个队列，参数指定队列可以存储的元素的最大数量 */
                                  /* 注意：这个函数只适用于使用动态分配数组的队列 */
                                
void destroy_queue( void ); /* 注意：这个函数只适用于链式和动态分配数组的队列 */

void insert( QUEUE_TYPE value ); /* 添加新元素 */

void delete( void ); /* 移除一个元素并将其丢弃 */

QUEUE_TYPE first( void ); /* 返回队列中第一个元素的值，但不修改队列本身 */

int is_empty( void ); /* 判断队列是否为空 */
int is_full( void ); /* 判断队列是否已满 */

 

用静态数组实现队列：

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

#define QUEUE_SIZE 100 /* 队列中元素的最大数量 */
#define ARRAY_SIZE ( QUEUE_SIZE + 1 ) /* 数组的长度 */、

/* 用于存储队列元素的数组和指向队列头和尾的指针 */
static QUEUE_TYPE queue[ ARRAY_SIZE ];
static size_t front = 1;
static size_t rear = 0;

/* insert */
void insert( QUEUE_TYPE value )
{
    assert( !is_full() );
    rear = ( rear + 1 ) % ARRAY_SIZE;
    queue[ rear ] = value;
}

/* delete */
void delete( void )
{
    assert( !is_empty() );
    front = ( front + 1 ) % ARRAY_SIZE;
}

/* first */
QUEUE_TYPE first( void )
{
    assert( !is_empty() );
    return queue[ front ];
}

/* is_empty */
int is_empty( void )
{
    return ( rear + 1 ) % ARRAY_SIZE == front;
}

/* is_full */
int is_full( void )
{
    return ( rear + 2 ) % ARRAY_SIZE == front;
}

 

动态数组实现队列：

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

static QUEUE_TYPE *queue;
static size_t queue_size;
static size_t front = 1;
static size_t rear = 0;

void create_queue( size_t size )
{
    assert( queue_size == 0 );
    queue_size = size;
    queue = (QUEUE_TYPE*)malloc( queue_size * sizeof( QUEUE_TYPE ) );
    assert( queue != NULL );
}

void destroy_queue( void )
{
    assert( queue_size > 0 );
    queue_size = 0;
    free( queue );
    queue = NULL;
}

/*resize_stack函数，这个函数接收一个参数：堆栈的新长度 */
void resize_queue( size_t new_size )
{
    QUEUE_TYPE *old_queue;
    int i;
    int rear_plus_one;
    
    /* 确保空间足够大来保证数据在队列中,然后把指针保存到旧的数组中并创建一个新的 */
    if( front <= rear )
        i = rear – front + 1;
    else 
        i = queue_size – front + rear + 1;
    i %= queue_size;
    assert( new_size >= i );
    old_queue = queue;
    queue = (QUEUE_TYPE*)malloc( new_size * sizeof( QUEUE_TYPE ) );
    assert( queue != NULL );
    queue_size = new_size;
    
    /*把旧数组的值复制到新数组中，然后释放旧数组的内存*/
    i = 0;
    rear_plus_one = ( rear + 1 ) % queue_size;
    while( front != rear_plus_one)
    {
        queue[ i ] = old_queue[ front ];
        front = ( front + 1 ) % queue_size; 
        i += 1;
    }
    front = 0;
    rear = ( i + queue_size – 1 ) % queue_size;
    free( old_queue );
}

void insert( QUEUE_TYPE value )
{
    assert( !is_full() );
    rear = ( rear + 1 ) % queue_size;
    queue[ rear ] = value;
}

void delete( void )
{
    assert( !is_empty() );
    front = ( front + 1 ) % queue_size;
}

QUEUE_TYPE first( void )
{
    assert( !is_empty() );
    return queue[ front ];
}

int is_empty( void )
{
    assert( queue_size > 0 );
    return( rear + 1 ) % queue_size == front;
}

int is_full( void )
{
    assert( queue_size > 0 );
    return( rear + 2 ) % queue_size == front;
}

用链表实现队列：

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

/* 定义一个结构来保存一个值，link字段将指向队列中的下一个节点 */
typedef struct QUEUE_NODE
{
    QUEUE_TYPE value;
    struct QUEUE_NODE *next;
}QueueNode;

/* 指向队列第一个和最后一个节点的指针 */
static QueueNode *front;
static QueueNode *rear;

/* destroy_queue */
void destroy_queue( void )
{
    while( !is_empty() )
        delete();
}

/* insert */
void insert( QUEUE_TYPE value )
{
    QueueNode *new_node;

    /* 分配一个新节点，并填充它的各个字段 */
    new_node = ( QueueNode *)malloc( sizeof( QueueNode ) );
    assert( new_node != NULL );
    new_node -> next = NULL;

    /* 把它插入到队列的尾部 */
    if( rear == NULL )
    {
        front = new_node;
    }
    else
    {
        rear -> next = new_node;
    }
    rear = new_node;
}

/* delete */
void delete( void )
{
    QueueNode *next_node;

    /* 从队列的头部开始删除一个节点，如果它是最后一个节点，将rear置为NULL */
    assert( !is_empty() );
    next_node = front -> next;
    free( front );
    front = next_node;
    if( front == NULL )
        rear = NULL;
}

/* first */
QUEUE_TYPE first( void )
{
    assert( !is_empty() );
    return front -> value;
}

/* is_empty() */
int is_empty( void )
{
    return front == NULL;
}

/* is_full() */
int is_full( void )
{
   return 0;
}