解析栈和队列面试题

一、实现一个栈，要求实现Push（入栈）、Pop（出栈）、Min（返回最小值）的时间复杂度为O(1)

思路：

1、首先定义两个栈（s，min），栈s存放数据，栈min存放当前所有数据的最小值
2、对于栈s正常入栈，出栈就可以
3、对于栈min，当栈min为空或者入栈的数据x小于等于栈min栈顶元素的值就将x入栈；当栈s栈顶元素的值等于栈min栈顶元素的值，栈min进行出栈操作
4、取栈min栈顶元素的值即为当前的最小值

// 入栈
void Push(Stack *s, Stack *min, DataType x)
{
		StackPush(s, x);
		if (StackEmpty(min) || x <= StackTop(min))
		{
			StackPush(min, x);
		}
}

// 出栈
void Pop(Stack *s, Stack *min)
{
	if (StackTop(s) == StackTop(min))
	{
		StackPop(min);
	}
	StackPop(s);
}

// 返回最小值
int GetMin(Stack *min)
{
	if (!StackEmpty(min))
	{
		return StackTop(min);
	}
}

二、判断元素出栈，入栈顺序的合法性。如入栈的序列（1，2，3，4，5），出栈的序列（3，4，2，1，5）

int Test_Legality(int *in, int *out, int size) // in为入栈序列数组指针，out为出栈序列数组指针，size为数组大小
{
	Stack s;
	StackInit(&s);
	int i = 0;
	int j = 0;
	for (i = 0; i < size; i++)
	{
		StackPush(&s, in[i]);
		while (!StackEmpty(&s) && StackTop(&s) == out[j])
		{
			StackPop(&s);
			j++;
		}
	}
	return StackEmpty(&s); // 当所有出栈序列元素都匹配完之后，此时栈为空，即合法；否则不合法
}

三、使用两个栈实现一个队列

// 入队
void TwoStack_Queue_Push(Stack *s1, DataType x) // 入数据只在s1中入
{
	StackPush(s1, x);  
}

// 出队
void TwoStack_Queue_Pop(Stack *s1, Stack *s2)  // 出数据只在s2中出
{
	if (StackEmpty(s2)) // 当s2为空时，先把s1中的数据倒到s2中去
	{
		while (!StackEmpty(s1))
		{
			StackPush(s2, StackTop(s1));
			StackPop(s1);
		}
	}
	StackPop(s2);
}

// 返回队头元素
DataType TwoStack_Queue_Front(Stack *s1, Stack *s2)
{
	if (StackEmpty(s2))
	{
		while (!StackEmpty(s1))
		{
			StackPush(s2, StackTop(s1));
			StackPop(s1);
		}
	}
	return StackTop(s2);
}

四、使用两个队列实现一个栈

思路：

1、第一次入数据时，两个队列（q1，q2）都为空，先将数据入到q2中去；之后入数据都往不为空的那个队列入，保证一个队列为空，一个队列不为空
2、出数据时，将不为空的那个队列中的前size-1个数据依次Push到为空的那个队列里，依次Pop后保留最后一个，再将其Pop掉

// 入栈
void TwoQueue_Stack_Push(Queue *q1, Queue *q2, DataType x)
{
	if (!QueueEmpty(q1)) // q1不为空，将x入到q1中去
	{
		QueuePush(q1, x);
	}
	else // q1为空，将x入到q2中去
	{
		QueuePush(q2, x);
	}
}

// 出栈
void TwoQueue_Stack_Pop(Queue *q1, Queue *q2)
{
	if (QueueEmpty(q1)) // 如果q1为空，将q2中的元素依次入到q1中（除了最后一个元素）
	{
		int size = QueueSize(q2);
		while (--size)
		{
			QueuePush(q1, QueueFront(q2));
			QueuePop(q2);
		}
		QueuePop(q2);
	}
	else // 如果q1不为空，将q1中的元素依次入到q2中（除了最后一个元素）
	{
		int size = QueueSize(q1);
		while (--size)
		{
			QueuePush(q2, QueueFront(q1));
			QueuePop(q1);
		}
		QueuePop(q1);
	}
}

// 获取栈顶元素
DataType TwoQueue_Stack_Top(Queue *q1, Queue *q2)
{
	if (!QueueEmpty(q1))
	{
		return QueueFront(q1);
	}
	else
	{
 		return QueueFront(q2);
	}
}

五、一个数组实现两个栈（共享栈）

方法：奇偶栈、中间栈、头尾栈

以奇偶栈为例，具体实现如下：

• Stack.h

#ifndef __Stack_h__
#define __Stack_h__

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <Windows.h>

#define Initsize 4 //初始存储空间
#define Increment 2 //每次增量

typedef int DataType;

typedef struct Stack
{
	DataType* _array;
	size_t _size1; // 栈1的有效数据个数
	size_t _size2; // 栈2的有效数据个数
	size_t _capacity; //总容量 
}Stack;

void StackInit(Stack* s);
void CheckCapacity(Stack* s);
void StackPush(Stack* s, DataType x, int which);
void StackPop(Stack* s, int which);
DataType StackTop(Stack* s, int which);
int StackEmpty(Stack* s, int which);
void StackPrint(Stack *s, int which);

#endif __Stack_h__

• Stack.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "Stack.h"

//初始化
void StackInit(Stack* s)
{
	assert(s);
	s->_size1 = 0;
	s->_size2 = 0;
	s->_capacity = Initsize;
	s->_array = (DataType*)malloc(Initsize*sizeof(DataType));
	if (s->_array == NULL)
	{
		perror("StackInit");
		return;
	}
	memset(s->_array, 0, s->_capacity * sizeof(DataType));
}

//扩容
void CheckCapacity(Stack* s)
{
	assert(s);
	if (s->_size1 >= s->_capacity / 2 || s->_size2 >= s->_capacity / 2)
	{
		DataType* ptr = (DataType*)realloc(s->_array, (s->_capacity + Increment)*sizeof(DataType));
		if (ptr == NULL)
		{
			perror("CheckCapacity");
		}
		else
		{
			s->_array = ptr;
			s->_capacity += Increment;
		}
	}
}

//入栈
void StackPush(Stack* s, DataType x ,int which)
{
	assert(s);
	CheckCapacity(s);
	if (which == 1)
	{
		static int i = 0; // 栈1在偶数位
		s->_array[i] = x;
		s->_size1++;
		i = i + 2;
	}
	else if (which == 2)
	{
		static int j = 1; // 栈2在奇数位
		s->_array[j] = x;
		s->_size2++;
		j = j + 2;
	}
}

//出栈
void StackPop(Stack* s, int which)
{
	assert(s);
	if (which == 1)
	{
		if (s->_size1 == 0)
		{
			printf("栈1为空\n");
		}
		else
		{
			s->_size1--;
		}
	}
	else if (which == 2)
	{
		if (s->_size2 == 0)
		{
			printf("栈2为空\n");
		}
		else
		{
			s->_size2--;
		}
	}
}

//获取栈顶元素
DataType StackTop(Stack* s, int which)
{
	assert(s);
	if (which == 1)
	{
		if (s->_size1 == 0)
		{
			printf("栈1为空\n");
			return -1;
		}
		return s->_array[((s->_size1) - 1) * 2];
	}
	else if (which == 2)
	{
		if (s->_size2 == 0)
		{
			printf("栈2为空\n");
			return -1;
		}
		return s->_array[((s->_size2) - 1) * 2 + 1];
	}
}

//判空
int StackEmpty(Stack* s, int which)
{
	assert(s);
	if (which == 1)
	{
		if (s->_size1)
		{
			return 0;
		}
		else
		{
			return 1;
		}
	}
	else if (which == 2)
	{
		if (s->_size2)
		{
			return 0;
		}
		else
		{
			return 1;
		}
	}
}

//打印
void StackPrint(Stack *s, int which)
{
	assert(s);
	if (which == 1)
	{
		if (StackEmpty(s, 1))
		{
			printf("栈1为空\n");
		}
		else
		{
			int i = 0;
			while (s->_size1--)
			{
				printf("%d ", s->_array[i]);
				i = i + 2;
			}
			printf("\n");
		}
	}
	else if (which == 2)
	{
		if (StackEmpty(s, 2))
		{
			printf("栈2为空\n");
		}
		else
		{
			int j = 1;
			while (s->_size2--)
			{
				printf("%d ", s->_array[j]);
				j = j + 2;
			}
			printf("\n");
		}
	}
}