两个栈实现一个队列——两个队列实现一个栈

题目：两个栈实现一个队列

#include<stdio.h>
#include<assert.h>
#include<malloc.h>
#include<stdlib.h>
#include<string.h>
//stack.h 

typedef int DataType;
typedef struct Stack{
  DataType *array;
  int top;
  int capacity;
}Stack;

typedef struct Queue{
  Stack pushStack;
  Stack popStack;
}Queue;

///栈：stack.c//



void StackInit(Stack *s,int capacity)
{
  s->array = (DataType *)malloc(sizeof(DataType)*capacity);
  assert(s->array);
  s->capacity = capacity;
  s->top = 0;
}

void CheckMemory(Stack *s)
{
  if(s->top == s->capacity)
  {
    s->capacity *=2;
    DataType *NewArr = (DataType *)malloc(sizeof(DataType)*s->capacity);
    assert(NewArr);
    memset(NewArr,0,sizeof(DataType)*s->capacity);
    memcpy(NewArr,s->array,sizeof(DataType)*s->top);
    free(s->array);
    s->array = NewArr;
  }
}

int StackTop(Stack *s)
{
  return s->array[s->top-1];
}

void StackPush(Stack *s,DataType data)
{
  CheckMemory(s);
  s->array[s->top++] = data;
}

void StackPrint(Stack *s)
{
  if(s->top == 0)
    return;
  int i = 0;
  for(;i<s->top;i++)
  {
    printf("%d ",s->array[i]);
  }
  printf("\n");
}

void StackPop(Stack *s)
{
  if(s->top == 0)
    return;
  else 
  {
    s->array[s->top-1] = 0;
    --s->top;
  }
}

int StackIsEmpty(Stack *s)
{
  if(s->top == 0)
    return 0;
  else 
    return 1;
}

int StackSize(Stack *s)
{
  return s->top;
}

/ 
//队列操作
void QueueInit(Queue *q)
{
  StackInit(&q->pushStack,2);
  StackInit(&q->popStack,2);
}

void QueuePush(Queue *q,DataType data)
{
  StackPush(&q->pushStack,data);
}


void QueuePop(Queue *q)
{
  if(StackIsEmpty(&q->popStack) == 0)
  {
    while(StackIsEmpty(&q->pushStack) != 0)
    {
      StackPush(&q->popStack,StackTop(&q->pushStack));
      StackPop(&q->pushStack);
    }
    StackPop(&q->popStack);
  }
  else 
    StackPop(&q->popStack);
}

int main()
{
  Queue q;
  QueueInit(&q);
  QueuePush(&q,1);
  //QueuePush(&q,2);
  //QueuePush(&q,3);
  //QueuePush(&q,4);
  //QueuePush(&q,5);
  //QueuePush(&q,6);
  StackPrint(&q.pushStack);
  QueuePop(&q);
  QueuePush(&q,2);
  StackPrint(&q.popStack);
  QueuePop(&q);
  QueuePush(&q,3);
  StackPrint(&q.popStack);
  StackPrint(&q.pushStack);
  return 0;
}

题目：两个队列实现一个栈

 

 

#include<stdio.h>
#include<malloc.h>
#include<string.h>
#include<stdlib.h>
#include<assert.h>
typedef int DataType;

typedef struct QueueNode{
  struct QueueNode *next;
  DataType data;
}QueueNode;

typedef struct Queue{
  QueueNode *Head;
  QueueNode *Tail;
}Queue;

typedef struct Stack{
  Queue q1;
  Queue q2;
}Stack;


void QueueInit(Queue *q)
{
  assert(q);
  q->Head = NULL;
  q->Tail = NULL;
}

QueueNode *BuyNode(DataType data)
{
  QueueNode *NewNode = (QueueNode *)malloc(sizeof(QueueNode));
  assert(NewNode);
  NewNode->next = NULL;
  NewNode->data = data;
  return NewNode;
}

void QueuePush(Queue *q,DataType data)
{
  assert(q);
  if(q->Head == NULL)
    q->Head = q->Tail = BuyNode(data);
  else 
  {
    q->Tail->next = BuyNode(data);
    q->Tail = q->Tail->next;
  }
}

void QueuePop(Queue *q)
{
  assert(q);
  if(q->Head == NULL)
    return;
  QueueNode *cur = q->Head;
  q->Head = cur->next;
  free(cur);
  cur = NULL;
}

int QueueIsEmpty(Queue *q)
{
  if(q->Head == NULL)
    return 0;
  else 
    return 1;
}

int QueueSize(Queue *q)
{
  int count = 0;
  QueueNode *cur = q->Head;
  while(cur != NULL)
  {
    ++count;
    cur = cur->next;
  }
  return count;
}

void QueuePrint(Queue *q)
{
  assert(q);
  QueueNode *cur = q->Head;
  while(cur != NULL)
  {
    printf("%d ",cur->data);
    cur = cur->next;
  }
  printf("\n");
}

DataType QueueTop(Queue *q)
{
  assert(q);
  if(q->Head != NULL)
    return q->Head->data;
  else 
    return -1;
}


void StackInit(Stack *s)
{
  assert(s);
  QueueInit(&s->q1);
  QueueInit(&s->q2);
}

void StackPush(Stack *s,DataType data)
{
  if(s->q1.Head == NULL && s->q2.Head == NULL)
  {
    QueuePush(&s->q1,data);
  }
  else if(s->q1.Head != NULL)
  {
    QueuePush(&s->q1,data);
  }
  else 
    QueuePush(&s->q2,data);
}

void StackPop(Stack *s)
{
  assert(s);
  if(QueueIsEmpty(&s->q1) != 0)
  {
    while(QueueSize(&s->q1) != 1)
    {
      QueuePush(&s->q2,QueueTop(&s->q1));
      QueuePop(&s->q1);
    }
    QueuePop(&s->q1);
  }
  else if(QueueIsEmpty(&s->q2) != 0)
  {
    while(QueueSize(&s->q2) != 1)
    {
      QueuePush(&s->q1,QueueTop(&s->q2));
      QueuePop(&s->q2);
    }
    QueuePop(&s->q2);
  }
}

void test()
{
  Stack s;
  StackInit(&s);
  StackPush(&s,1);
  StackPush(&s,2);
  StackPush(&s,3);
  StackPush(&s,4);
  StackPush(&s,5);
  QueuePrint(&s.q1);
  StackPop(&s);
  QueuePrint(&s.q1);
  QueuePrint(&s.q2);
  StackPush(&s,6);
  QueuePrint(&s.q2);
  StackPop(&s);
  QueuePrint(&s.q1);
 // Queue q;
 // QueueInit(&q);
 // QueuePush(&q,1);
 // QueuePush(&q,2);
 // QueuePush(&q,3);
 // QueuePush(&q,4);
 // printf("size = %d\n",QueueSize(&q));
 // printf("ret = %d\n",QueueIsEmpty(&q));
 // QueuePrint(&q);
}

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