顺序存储结构-队列

• 目录
• 顺序存储结构-队列

顺序存储结构-队列

//queue.c
#include 
#include 

//类型
typedef struct node{
    int* data;
    int size;

    int head;
    int tail;

}queue_t;
//创建
queue_t* create_queue(int size)
{
    if(size<=1)
    {
        return NULL;
    }

    queue_t* queue=malloc(sizeof(queue_t));

    queue->size=size;

    queue->data=malloc(sizeof(int)*size);

    queue->head=queue->tail=0;

    return queue;
}
//判空
int isnull_queue(queue_t* queue)
{
    if(queue==NULL)
        return 0;

    return queue->head==queue->tail;
}
//判满
int isfull_queue(queue_t* queue)
{
    if(queue==NULL)
        return 0;

    //    return (queue->tail+1)%queue->size==queue->head;   //  %  mod  基于位置
    //2?
    //
    return (queue->tail-queue->head+queue->size)%queue->size==queue->size-1;
    //基于长度
}
//入队
int push_queue(queue_t* queue,int data)
{
    if(queue==NULL||isfull_queue(queue))
        return -1;

    queue->data[queue->tail]=data;

    queue->tail=(queue->tail+1)%queue->size;

    return 0;
}
//出队
int pop_queue(queue_t* queue,int* data)
{
    if(queue==NULL||isnull_queue(queue))
        return -1;

    *data=queue->data[queue->head];

    queue->data[queue->head]=0;
//    非必要过程

    queue->head=(queue->head+1)%queue->size;

    return 0;
}

//长度
int length_queue(queue_t* queue)
{
    if(queue==NULL||isnull_queue(queue))
        return 0;

    return (queue->tail-queue->head+queue->size)%queue->size;
}
//正打印（假）
int print_queue_notreal(queue_t* queue)
{
    if(queue==NULL||isnull_queue(queue))
        return -1;

    int i;

    for(i=0;i<queue->size;i++)
    {
        printf("%3d ",queue->data[i]);
    }
    printf("\n");

    return 0;
}
//正打印（略假）  从h  -》 t
int print_queue_htot(queue_t* queue)
{
    if(queue==NULL||isnull_queue(queue))
        return -1;

    int i;

    for(i=queue->head;i!=queue->tail;i=(i+1)%queue->size)
    {
        printf("%3d ",queue->data[i]);
    }
    printf("\n");

    return 0;
}
//清空
int clear_queue(queue_t* queue)
{
    if(queue==NULL)
        return -1;


    queue->tail=queue->head=0;

    return 0;
}
//销毁
int destroy_queue(queue_t* queue)
{
    if(queue==NULL)
        return -1;

    free(queue->data);

    free(queue);

    return 0;
}

//逆打印（真）   栈 两个 or  一个 过河拆桥:
int reprint_queue_real(queue_t* queue)
{
    if(queue==NULL||isnull_queue(queue))
        return -1;

    int * stack1=malloc(sizeof(int)*length_queue(queue));

    int top1=-1;

    int * stack2=malloc(sizeof(int)*length_queue(queue));

    int top2=-1;

    int data;
    while(!isnull_queue(queue))
    {
        pop_queue(queue,&data);

        stack1[++top1]=data;
    }

    while(top1!=-1)
    {
        data=stack1[top1--];

        printf("%3d ",data);

        stack2[++top2]=data;
    }

    printf("\n");

    while(top2!=-1)
    {
        data=stack2[top2--];

        push_queue(queue,data);
    }

    free(stack1);
    free(stack2);

    return 0;
}
//正打印（真）  队列  过河拆桥
int print_queue_real(queue_t* queue)
{
    if(queue==NULL||isnull_queue(queue))
        return -1;

    queue_t* temp=create_queue(length_queue(queue)+1);

    int data;
    while(!isnull_queue(queue))
    {
        pop_queue(queue,&data);

        printf("%3d ",data);

        push_queue(temp,data);
    }
    printf("\n");

    while(!isnull_queue(temp))
    {
        pop_queue(temp,&data);

        push_queue(queue,data);

    }
    destroy_queue(temp);

    return 0;
}

int main(int argc, const char *argv[])
{
    queue_t* queue=create_queue(20);

    int i;
    for(i=1;i<=20;i++)
    {
        if(0==push_queue(queue,i))
            print_queue_htot(queue);

    }

    print_queue_notreal(queue);

    print_queue_real(queue);

    print_queue_notreal(queue);


    reprint_queue_real(queue);
    print_queue_notreal(queue);

//    print_queue_htot(queue);

    destroy_queue(queue);

#if 0
    int data;
    for(i=1;i<=20;i++)
    {
        if(0==pop_queue(queue,&data))
        {
        printf("pop data:%d\n",data);

    //    print_queue_notreal(queue);
        print_queue_htot(queue);
        }

    }
#endif

    return 0;
}