1、最小栈
#include <stdio.h>
#include "seqstack.h"
typedef struct Min_SeqStack {
SeqStack stack;
}Min_SeqStack;
void Min_SeqStackPrint(Min_SeqStack* s)
{
if(s == NULL) {
return;
}
size_t i = 0;
for(; i < s->stack.size; i++) {
printf("%c ", s->stack.data[i]);
}
printf("\n");
}
void Min_SeqStackInit(Min_SeqStack* s)
{
if(s == NULL) {
return;
}
SeqStackInit(&s->stack);
return;
}
void Min_SeqStackPush(Min_SeqStack* s, SeqStackType value)
{
if(s == NULL) {
return;
}
SeqStackType top;
SeqStackType min;
if(s->stack.size == 0) {
SeqStackPush(&s->stack, value);
SeqStackPush(&s->stack, value);
} else {
SeqStackGetFront(&s->stack, &top);
min = top < value ? top : value;
SeqStackPush(&s->stack, value);
SeqStackPush(&s->stack, min);
}
return;
}
void Min_SeqStackPop(Min_SeqStack* s)
{
if(s == NULL) {
return;
}
if(s->stack.size == 0) {
return;
}
SeqStackPop(&s->stack);
SeqStackPop(&s->stack);
}
int Min_SeqStackTop(Min_SeqStack* s, SeqStackType* value)
{
if(s == NULL) {
return -1;
}
if(s->stack.size == 0) {
return -1;
}
return SeqStackGetFront(&s->stack, value);
}
int main()
{
Min_SeqStack s;
Min_SeqStackInit(&s);
Min_SeqStackPush(&s, 'a');
Min_SeqStackPush(&s, 'c');
Min_SeqStackPush(&s, 'd');
Min_SeqStackPush(&s, 's');
Min_SeqStackPrint(&s);
SeqStackType value;
Min_SeqStackTop(&s, &value);
Min_SeqStackPrint(&s);
printf("%c\n", value);
Min_SeqStackPop(&s);
Min_SeqStackPrint(&s);
Min_SeqStackTop(&s, &value);
printf("%c\n", value);
Min_SeqStackPop(&s);
Min_SeqStackPrint(&s);
Min_SeqStackTop(&s, &value);
printf("%c\n", value);
Min_SeqStackPop(&s);
Min_SeqStackPrint(&s);
Min_SeqStackTop(&s, &value);
printf("%c\n", value);
return 0;
}
2、用两个栈实现一个队列
#include <stdio.h>
#include "seqstack.h"
typedef struct queue_by2stackInit {
SeqStack input;//这个栈为桥梁栈
SeqStack output;//这个为实际的队列栈
}queue_by2stack;
void queue_by2stackInit(queue_by2stack* q)//初始化新的队列
{
if(q == NULL)
{
return;
}
SeqStackInit(&q->input);
SeqStackInit(&q->output);
return;
}
void queue_by2stackPush(queue_by2stack* q, SeqStackType value)//入队
{
if(q == NULL) {
return;
}
SeqStackType top;
int ret;
while(1) {
ret = SeqStackGetFront(&q->output, &top);
if(ret == -1) {
break;
}
SeqStackPush(&q->input, top);
SeqStackPop(&q->output);
}
SeqStackPush(&q->input, value);
while(1) {
ret = SeqStackGetFront(&q->input, &top);
if(ret == -1) {
break;
}
SeqStackPush(&q->output, top);
SeqStackPop(&q->input);
}
return;
}
void queue_by2stackPop(queue_by2stack* q)//出队
{
if(q == NULL) {
return;
}
SeqStackPop(&q->output);
return;
}
int queue_by2stackTop(queue_by2stack* q, SeqStackType* value)//取队首元素
{
if(q == NULL || value == NULL)
{
return -1;
}
if(q->output.size == 0) {
return -1;
}
SeqStackGetFront(&q->output, value);
return 1;
}
void queue_by2stackPrint(queue_by2stack* q)
{
if(q == NULL) {
return;
}
size_t i = 0;
for(; i < q->output.size; ++i) {
printf("%c ", q->output.data[i]);
}
printf("\n");
}
int main()
{
queue_by2stack q;
queue_by2stackInit(&q);
queue_by2stackPush(&q, 'a');
queue_by2stackPush(&q, 'b');
queue_by2stackPush(&q, 'c');
queue_by2stackPush(&q, 'd');
queue_by2stackPrint(&q);
SeqStackType value;
int ret;
ret = queue_by2stackTop(&q,&value);
printf("expected ret 1, actual ret %d\n",ret);
printf("expected value a, actual value %c\n",value);
queue_by2stackPop(&q);
queue_by2stackPrint(&q);
ret = queue_by2stackTop(&q,&value);
printf("expected value b, actual value %c\n",value);
printf("expected ret 1, actual %d\n",ret);
queue_by2stackPop(&q);
queue_by2stackPrint(&q);
ret = queue_by2stackTop(&q,&value);
printf("expected ret 1, actual %d\n",ret);
printf("expected value c, actual value %c\n",value);
queue_by2stackPop(&q);
queue_by2stackPrint(&q);
ret = queue_by2stackTop(&q,&value);
printf("expected ret 1, actual %d\n",ret);
printf("expected value d, actual value %c\n",value);
queue_by2stackPop(&q);
queue_by2stackPrint(&q);
ret = queue_by2stackTop(&q,&value);
printf("expected ret -1, actual %d\n",ret);
return 0;
}
3、两个队列实现一个栈
#include <stdio.h>
#include "seqqueue.h"
typedef struct stack_by2queue{
SeqQueue queue1;
SeqQueue queue2;
}stack_by2queue;
void stack_by2queueInit(stack_by2queue* q)//初始化栈
{
if(q == NULL)
{
return;
}
SeqQueueInit(&q->queue1);
SeqQueueInit(&q->queue2);
return;
}
void stack_by2queuePush(stack_by2queue* q, SeqQueueType value)//入栈
{
if(q == NULL) {
return;
}
if(q->queue1.size != 0) {
SeqQueuePush(&q->queue1, value);
} else {
SeqQueuePush(&q->queue2, value);
}
return;
}
void stack_by2queuePop(stack_by2queue* q)//出栈
{
if(q == NULL) {
return;
}
if(q->queue1.size == 0 && q->queue2.size == 0) {
return;
}
SeqQueueType top;
while(1) {
if(q->queue1.size != 0) {
while(1)
{
if(q->queue1.size == 1) {
SeqQueuePop(&q->queue1);
return;
}
SeqQueueGetFront(&q->queue1, &top);
SeqQueuePush(&q->queue2, top);
SeqQueuePop(&q->queue1);
}
} else {
while(1)
{
if(q->queue2.size == 1) {
SeqQueuePop(&q->queue2);
return;
}
SeqQueueGetFront(&q->queue2, &top);
SeqQueuePush(&q->queue1, top);
SeqQueuePop(&q->queue2);
}
}
}
}
int stack_by2queueTop(stack_by2queue* q, SeqQueueType* value)//取栈顶元素
{
if(q == NULL) {
return -1;
}
if(q->queue1.size == 0 && q->queue2.size == 0) {
return -1;
}
while(1) {
if(q->queue1.size != 0) {
while(1)
{
SeqQueueGetFront(&q->queue1, value);
SeqQueuePush(&q->queue2, *value);
SeqQueuePop(&q->queue1);
if(q->queue1.size == 0) {
return 1;
}
}
} else {
while(1)
{
SeqQueueGetFront(&q->queue2, value);
SeqQueuePush(&q->queue1, *value);
SeqQueuePop(&q->queue2);
if(q->queue2.size == 0) {
return 1;
}
}
}
}
}
void stack_by2queuePrint(stack_by2queue* q)
{
if(q == NULL) {
return;
}
size_t i = 0;
if(q->queue1.size != 0) {
for(i = q->queue1.head; i != q->queue1.tail; ++i) {
if(i >= SQUEUEMAX) {
i = 0;
}
printf("%c ",q->queue1.data[i]);
}
} else {
for(i = q->queue2.head; i != q->queue2.tail; ++i) {
if(i >= SQUEUEMAX) {
i = 0;
}
printf("%c ",q->queue2.data[i]);
}
}
printf("\n");
return;
}
int main()
{
stack_by2queue q;
SeqQueueType value;
int ret;
stack_by2queueInit(&q);
stack_by2queuePush(&q, 'a');
stack_by2queuePush(&q, 'b');
stack_by2queuePush(&q, 'c');
stack_by2queuePush(&q, 'd');
stack_by2queuePrint(&q);
ret = stack_by2queueTop(&q, &value);
printf("expected ret 1, actual ret %d\n",ret);
printf("expected value d, actual value %c\n",value);
stack_by2queuePop(&q);
stack_by2queuePrint(&q);
ret = stack_by2queueTop(&q, &value);
ret = stack_by2queueTop(&q, &value);
printf("expected ret 1, actual ret %d\n",ret);
printf("expected value c, actual value %c\n",value);
stack_by2queuePop(&q);
stack_by2queuePrint(&q);
ret = stack_by2queueTop(&q, &value);
ret = stack_by2queueTop(&q, &value);
printf("expected ret 1, actual ret %d\n",ret);
printf("expected value b, actual value %c\n",value);
stack_by2queuePop(&q);
stack_by2queuePrint(&q);
ret = stack_by2queueTop(&q, &value);
ret = stack_by2queueTop(&q, &value);
printf("expected ret 1, actual ret %d\n",ret);
printf("expected value a, actual value %c\n",value);
stack_by2queuePop(&q);
stack_by2queuePrint(&q);
ret = stack_by2queueTop(&q, &value);
ret = stack_by2queueTop(&q, &value);
printf("expected ret -1, actual ret %d\n",ret);
return 0;
}
4、判断字符串是否按出栈顺序
#include <stdio.h>
#include "seqstack.h"
int str_instack(SeqStack* s, char* str1, char* str2, int len)//str1位入栈顺序,str2位字符串
{
if(str1 == NULL || str2 == NULL) {
return -1;
}
SeqStackType top;
SeqStackInit(s);
int i = 0;
for(; i < len; ++i) {
SeqStackPush(s, *str1);
SeqStackGetFront(s, &top);//取栈顶元素比较
while(top == *str2) {
SeqStackPop(s);
SeqStackGetFront(s, &top);
str2++;
}
if(*str2 == '\0') {//如果str2到达'\0'证明字符串判断结束,即可以经过入栈出栈得到字符串
return 1;
}
str1++;
}
return -1;
}
int main()
{
SeqStack s;
int ret;
char str1[5] = {'a', 'b', 'c', 'd', 'e'};
char str2[5] = {'a', 'c', 'd', 'e', 'b'};
char str3[5] = {'a', 'd', 'b', 'e', 'c'};
int len = sizeof(str1)/sizeof(str1[0]);
ret = str_instack(&s, str1, str2, len);
printf("expected ret 1,actual ret %d\n",ret);
ret = str_instack(&s, str1, str3, len);
printf("expected ret -1,actual ret %d\n",ret);
return 0;
}