两个队列实现一个栈

基本实现原理

基本实现代码

①seqqueue.h

#pragma once
#include <stddef.h>

#define SeqQueueMaxSize 1000

typedef char SeqQueueType;

typedef struct SeqQueue{
    SeqQueueType data[SeqQueueMaxSize];
    //[head, tail)
    size_t head;
    size_t tail;
    //队列中元素个数
    size_t size;
}SeqQueue;

void SeqQueueInit(SeqQueue* q);

void SeqQueueDestory(SeqQueue* q);

void SeqQueuePush(SeqQueue* q, SeqQueueType value);

void SeqQueuePop(SeqQueue* q);

int SeqQueueFront(SeqQueue* q, SeqQueueType* value);

size_t SeqQueueSize(SeqQueue* q);

②seqqueue.c

#include "seqqueue.h"
#include <stdio.h>

void SeqQueueInit(SeqQueue* q){
    if(q == NULL){
        //非法输入
        return;
    }
    q->head = q->tail = 0;
    q->size = 0;
}

void SeqQueueDestory(SeqQueue* q){
    if(q == NULL){
        //非法输入
        return;
    }
    q->head = q->tail = 0;
    q->size = 0;
}

void SeqQueuePush(SeqQueue* q, SeqQueueType value){
    if(q == NULL){
        //非法输入
        return;
    }
    if(q->size == SeqQueueMaxSize){
        //队列已满
        return;
    }
    q->data[q->tail++] = value;
    q->tail %= SeqQueueMaxSize;
    //q->tail = (q->tail) & (SeqQueueMaxSize - 1);
    ++q->size;
}

void SeqQueuePop(SeqQueue* q){
    if(q == NULL){
        //非法输入
        return;
    }
    if(q->size == 0){
        //空队列
        return;
    }
    ++q->head;
    q->head %= SeqQueueMaxSize;
    --q->size;
}

int SeqQueueFront(SeqQueue* q, SeqQueueType* value){
    if(q == NULL || value == NULL){
        //非法输入
        return 0;
    }
    if(q->size == 0){
        //空队列
        return 0;
    }
    *value = q->data[q->head];
    return 1;
}

size_t SeqQueueSize(SeqQueue* q){
    if(q == NULL){
        //非法输入
        return (size_t)-1;
    } 
    return q->size;
}

//////////////////////////////////////////////////////////////////////////////
//以下是测试代码
/////////////////////////////////////////////////////////////////////////////
#if 0
void Test(){
    SeqQueue q;
    SeqQueueInit(&q);
    SeqQueuePush(&q, 'a');
    SeqQueuePush(&q, 'b');
    SeqQueuePush(&q, 'c');
    SeqQueuePush(&q, 'd');

    SeqQueueType tmp;
    SeqQueueFront(&q, &tmp);
    printf("tmp expect a, actual %c\n", tmp);

    SeqQueuePop(&q);
    SeqQueueFront(&q, &tmp);
    printf("tmp expect b, actual %c\n", tmp);

    SeqQueuePop(&q);
    SeqQueueFront(&q, &tmp);
    printf("tmp expect c, actual %c\n", tmp);

    SeqQueuePop(&q);
    SeqQueueFront(&q, &tmp);
    printf("tmp expect d, actual %c\n", tmp);
}

int main(){
    Test();
    return 0;
}
#endif

③stack_with_queue

#include <stdio.h>
#include "seqqueue.h"

typedef SeqQueueType StackType;

typedef struct Stack{
    SeqQueue queue1;
    SeqQueue queue2;
}Stack;

void StackInit(Stack* stack){
    if(stack == NULL){
        //非法输入
        return;
    }
    SeqQueueInit(&stack->queue1);
    SeqQueueInit(&stack->queue2);
}

void StackPush(Stack* stack, StackType value){
    if(stack == NULL){
        //非法输入
        return;
    }
    SeqQueue* entry = SeqQueueSize(&stack->queue1) > 0 ? &stack->queue1 : &stack->queue2;
    SeqQueuePush(entry, value);
}

void StackPop(Stack* stack){
    if(stack == NULL){
        //非法输入
        return;
    }
    size_t size1 = SeqQueueSize(&stack->queue1);
    size_t size2 = SeqQueueSize(&stack->queue2);
    if(size1 == 0 && size2 == 0){
        //空栈
        return;
    }
    SeqQueue* exitus = size1 > 0 ? &stack->queue1 : &stack->queue2;
    SeqQueue* backup = size1 == 0 ? &stack->queue1 : &stack->queue2;
    while(SeqQueueSize(exitus) > 1){
        StackType tmp;
        SeqQueueFront(exitus, &tmp);
        SeqQueuePop(exitus);
        SeqQueuePush(backup, tmp);
    }
    SeqQueuePop(exitus);
}

int StackTop(Stack* stack, StackType* value){
    if(stack == NULL || value == NULL){
        //非法输入
        return 0;
    }
    size_t size1 = SeqQueueSize(&stack->queue1);
    size_t size2 = SeqQueueSize(&stack->queue2);
    if(size1 == 0 && size2 == 0){
        //空栈
        return 0;
    }
    SeqQueue* non_empty = size1 > 0 ? &stack->queue1 : &stack->queue2;
    SeqQueue* empty = size1 == 0 ? &stack->queue1 : &stack->queue2;
    StackType tmp;
    while(SeqQueueSize(non_empty) > 0){
        SeqQueueFront(non_empty, &tmp);
        SeqQueuePop(non_empty);
        SeqQueuePush(empty, tmp);
    }
    *value = tmp;
    return 1;
}

/////////////////////////////////////////////////////////////////////////////
//以下是测试代码
/////////////////////////////////////////////////////////////////////////////
void Test(){
    Stack stack;
    StackInit(&stack);
    StackPush(&stack, 'a');
    StackPush(&stack, 'b');
    StackPush(&stack, 'c');
    StackPush(&stack, 'd');

    StackType tmp;
    StackTop(&stack, &tmp);
    printf("tmp expect d, actual %c\n", tmp);

    StackPop(&stack);
    StackTop(&stack, &tmp);
    printf("tmp expect c, actual %c\n", tmp);

    StackPop(&stack);
    StackTop(&stack, &tmp);
    printf("tmp expect b, actual %c\n", tmp);

    StackPop(&stack);
    StackTop(&stack, &tmp);
    printf("tmp expect a, actual %c\n", tmp);
}

int main(){
    Test();
    return 0;
}