栈和队列笔试题

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;
}