基本实现原理
基本实现代码
①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;
}