C语言实现用两个栈实现一个队列的功能

方法1：用指针够着栈，再实现队列功能

#include <stdio.h>
#include <stdlib.h>
//#define NDEBUG
#include <assert.h>
//操作系统的异常处理中,NULL被定义为0指针,0指针是一个中断向量
//访问NULL->访问0指针->访问0号中断向量->触发系统处理访问空指针异常的程序
//抽象层可以想象为0
//#define NULL ((void*)0)
#undef NULL
#define NULL 0

//用两个栈实现一个队列的功能
//思路:栈->初始化、销毁、栈空、栈满、进栈、出栈、取栈顶元素
//队列->初始化、销毁、入队、出队、队空、队满、取队首元素
typedef struct stack {
    int* data;
    int size;   //栈顶
    int capacity;   //最大容量
}stack;

typedef struct Queue {
    stack input;
    stack output;
}queue;
//初始化队列函数
void QueueInit(queue *queue, int capacity);
//销毁队列函数
void QueueDestory(queue *queue);
//入队函数
void QueueInsert(queue *queue, int value);
//出队函数
void QueueOutput(queue *queue);
//取队首元素函数
int Queue_get_data(queue *queue, int *data);

void StackInit(stack *stack, int capacity);
void StackDestory(stack *stack);
int Stackempty(stack *stack);
int StackFull(stack *stack);
int StackInsert(stack *stack, int data);
int StackPop(stack *stack);
int Stack_get_data(stack *stack, int *data);

void StackInit(stack *stack, int capacity)
{
    stack->data = (int *)malloc(sizeof(int) * stack->capacity);
    stack->capacity = capacity;
    stack->size = 0;
}
void StackDestory(stack *stack)
{
    assert(stack);

    free(stack->data);
    stack->data = NULL;
    stack->capacity = 0;
    stack->size = 0;
}
/*
 * 错误表:
 * 0:成''功
 * 1:栈中有元素、且不空或者不满
 * 2:栈空
 * 3:栈满
 * ...
 */
int Stackempty(stack *stack)
{
    assert(stack);

    if (stack->size) 
        return 1;
    else
        return 2;
}
int StackFull(stack *stack)
{
    assert(stack);

    if (stack->size == stack->capacity)
        return 3;
    else
        return 1;
}
int StackInsert(stack *stack, int data)
{
    assert(stack);

   if (3 == StackFull(stack))
       return 3;

    stack->data[stack->size++] = data;
    printf("111.%d\n", stack->data[stack->size-1]);

    return 0;
}
int StackPop(stack *stack)
{
    assert(stack);

    if (2 == Stackempty(stack))
        return 2;
 
//    printf("222.\n");
    
    return stack->data[--stack->size];
}   
int Stack_get_data(stack *stack, int *data)
{
    assert(stack);

    if (2 == Stackempty(stack)) 
        return 2;

    *data = stack->data[stack->size];
    printf("data::>%d.\n", *data);

    return *data;
}
void Stack_show_all(stack *stack) 
{
    assert(stack);

    int flag = stack->size - 1;
    for (int i = flag;i>=0;i--) {
        printf("%d ", stack->data[i]);
    }
    printf("\n");
}

void QueueInit(queue *queue, int capacity)
{
    StackInit(&queue->input, capacity);
    StackInit(&queue->output, capacity);
}
void QueueDestory(queue *queue)
{
    StackDestory(&queue->input);
    StackDestory(&queue->output);
}
void QueueInsert(queue *queue, int value)
{
    assert(queue);

    StackInsert(&queue->input, value);
}
void QueueOutput(queue *queue)
{
    assert(queue);

    if (Stackempty(&queue->input) == 2)
        return;

    while ((queue->input).size) {
        //printf("(queue->input).size::>%d.\n", (queue->input).size);
        //printf("(queue->output).size::>%d.\n", (queue->output).size);
        StackInsert(&queue->output, StackPop(&queue->input));
    }
}
int Queue_get_data(queue *queue, int *data) 
{
   return Stack_get_data(&queue->output, data);
}
int main()
{
    int *data;
    struct Queue queue;
    QueueInit(&queue,10);
    
    QueueInsert(&queue, 1);
    QueueInsert(&queue, 2);
    QueueInsert(&queue, 3);
    QueueInsert(&queue, 4);
    QueueInsert(&queue, 5);
    Stack_show_all(&queue.input);

    QueueOutput(&queue);
    Stack_show_all(&queue.output);

    QueueDestory(&queue);
    printf("Hello world\n");
    return 0;
}

方法二：用数组实现栈功能，然后实现队列

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define maxsize 100

//建栈、判空、进队列、出队列、查看队列、
//创建栈
typedef struct Stack {
    int data[maxsize];
    int top;
}stack;
//队列定义为双栈
typedef struct Queue {
    stack s1;   //S1为主线
    stack s2;   //S2为用来反转的栈
}queue;

queue *Queuecreate() {
    queue* tempQueue = (queue *)malloc(sizeof(queue));
    tempQueue->s1.top = -1;
    tempQueue->s2.top = -1;
    return tempQueue;
}
bool queue_empty(queue* obj)
{
    if (obj->s1.top == -1)
        return false;
    return true;
}
void queue_push(queue* obj, int x)
{
    if (obj->s1.top > 100)
        return;

    //栈未空即反转,s1->s2->s1,将s1当成队列
    while(obj->s1.top != -1)
        obj->s2.data[++(obj->s2.top)] = obj->s1.data[(obj->s1.top)--];
    obj->s1.data[++(obj->s1.top)] = x;
    while (obj->s2.top != -1) 
        obj->s1.data[++(obj->s1.top)] = obj->s2.data[(obj->s2.top)--];
}
int queue_pop(queue *obj)
{
    if (obj->s1.top == -1)
        return -1;

    return obj->s1.data[obj->s1.top--];
}
void queue_show(queue *obj)
{
    int temp = obj->s1.top;
    while (temp != -1) {
        printf("%d ", obj->s1.data[temp--]);
    }
    printf("\n");
}
bool QueueDestory(queue *obj)
{
    free(obj);
}
int Queue_show_top(queue *obj)
{
    return obj->s1.data[obj->s1.top];
}

int main()
{
    queue *queue = NULL;
    queue = Queuecreate();
    queue_push(queue, 1);
    queue_push(queue, 2);
    queue_push(queue, 3);
    queue_show(queue);
    queue_push(queue, 4);
    queue_push(queue, 5);
    printf("top::>%d\n", Queue_show_top(queue));
    queue_show(queue);
    printf("Hello world\n");
    return 0;
}