顺序存储结构 - 队列

//queue.c
#include <stdio.h>
#include <stdlib.h>

// 类型
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;
}