[C语言][LeetCode][225]Implement Stack using Queues

题目

Implement Stack using Queues

Implement the following operations of a stack using queues.

push(x) – Push element x onto stack.

pop() – Removes the element on top of the stack.

top() – Get the top element.

empty() – Return whether the stack is empty.

Notes:

You must use only standard operations of a queue – which means only push to back, peek/pop from front, size, and is empty operations are valid.

Depending on your language, queue may not be supported natively. You may simulate a queue by using a list or deque (double-ended queue), as long as you use only standard operations of a queue.

You may assume that all operations are valid (for example, no pop or top operations will be called on an empty stack).

标签

Stack、Design

难度

简单

分析

题目意思是通过队列的操作，来实现栈的基本API。

实现思路是设计两个队列，栈的push操作时，先将队列A的元素从头到尾挪到队列B，然后再将新的元素放入队列A，然后再将队列B的元素从头到尾放回队列A，这样就完成了栈的push操作，相当于新插入的元素，放到了队列的front（栈的push操作，其实就是放到栈顶），其他操作类似队列的操作。

C代码实现

typedef int ElementType;

typedef struct QUEUE_T
{
ElementType value;
//int length;
struct QUEUE_T *next;
}QUEUE;

typedef struct QUEUE_T Node;

#define QUEUE_MAX_LEN 10

QUEUE * queue_create(void)
{
QUEUE * queue = (QUEUE *)malloc(sizeof(QUEUE));
if(NULL == queue)
{
printf("queue malloc fail\n");
return NULL;
}

memset(queue, 0, sizeof(QUEUE));
//queue->length = 0;
queue->next = NULL;

return queue;
}

bool queue_is_empty(QUEUE *queue)
{
return queue->next == NULL;
}

#if 0
bool queue_is_full(QUEUE *queue)
{
return queue->length == QUEUE_MAX_LEN;
}
#endif

ElementType queue_front(QUEUE *queue)
{
QUEUE * q = queue;

if(!q->next)
return -1;

while(q->next)
q = q->next;

return q->value;
}

ElementType queue_back(QUEUE *queue)
{
return queue->next->value;
}

int queue_push(QUEUE *queue, ElementType elem)
{
Node *node = (Node *)malloc(sizeof(Node));
if(NULL == node)
{
printf("node malloc fail\n");
return -1;
}
memset(node, 0, sizeof(Node));

memcpy(&node->value, &elem, sizeof(ElementType));
node->next = queue->next;

queue->next = node;
//queue->length++;

return 0;
}

void queue_pop(QUEUE *queue)
{
QUEUE *q,*temp;

q = temp = queue;

if(!queue || !queue->next)
return;

while(q->next)
{
temp = q;
q = q->next;
}

temp->next = NULL;
//queue->length--;

free(q);
}

typedef struct {
QUEUE * queueA;
QUEUE * queueB;
} Stack;

/* Create a stack */
void stackCreate(Stack *stack, int maxSize) {
stack->queueA = queue_create();
stack->queueB = queue_create();
}

/* Push element x onto stack */
void stackPush(Stack *stack, int element) {
while(!queue_is_empty(stack->queueA))
{
queue_push(stack->queueB, queue_front(stack->queueA));
queue_pop(stack->queueA);
}

queue_push(stack->queueA, element);

while(!queue_is_empty(stack->queueB))
{
queue_push(stack->queueA, queue_front(stack->queueB));
queue_pop(stack->queueB);
}
}

/* Removes the element on top of the stack */
void stackPop(Stack *stack) {
queue_pop(stack->queueA);
}

/* Get the top element */
int stackTop(Stack *stack) {
return queue_front(stack->queueA);
}

/* Return whether the stack is empty */
bool stackEmpty(Stack *stack) {
return queue_is_empty(stack->queueA);
}

/* Destroy the stack */
void stackDestroy(Stack *stack) {
if(stack)
{
free(stack->queueA);
free(stack->queueB);
}
}