栈与队列面试题

于 2019-01-08 17:21:47 发布
阅读量325 收藏 2
点赞数 3
分类专栏： 学习历程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lucky52529/article/details/86086058
版权

在这里插入图片描述

下面是这5道题c语言实现的源代码

bool isValid(char* s)//判断括号是否有效
{
	int len = strlen(s);
	int pos = 0;
	int* ans = (int*)malloc(sizeof(int)*len);
	for (int i = 0; i < len; i++)
	{
		if ((s[i] == '(') || (s[i] == '{') || (s[i] == '['))
		{
			ans[pos++] = s[i];
		}
		if (s[i] == ')')
		{
			if ('(' == ans[pos - 1])
			{
				pos--;
			}
			else
			{
				return false;
			}
		}
		if (s[i] == '}')
		{
			if ('{' == ans[pos - 1])
			{
				pos--;
			}
			else
			{
				return false;
			}
		}
		if (s[i] == ']')
		{
			if ('[' == ans[pos - 1])
			{
				pos--;
			}
			else
			{
				return false;
			}
		}
	}
	if (pos != 0)
	{
		return false;
	}
	return true;
}


typedef int QUDataType;//使用队列实现栈
typedef struct QueueNode
{
	struct QueueNode* _next;
	QUDataType _data;
}QueueNode;

typedef struct Queue
{
	QueueNode* _front; // 队头
	QueueNode* _tail; // 队尾
}Queue;

void QueueInit(Queue* pq)
{
	pq->_front = NULL;
}

void QueueDestory(Queue* pq)
{
	QueueNode* cur = pq->_front;
	while (cur)
	{
		QueueNode* next = cur->_next;
		free(cur);
		cur = next;
	}

	pq->_front = NULL;
}

QueueNode* BuyQueueNode(QUDataType x)
{

	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	newnode->_data = x;
	newnode->_next = NULL;
	return newnode;
}

void QueuePush(Queue* pq, QUDataType x)
{
	if (pq->_front == NULL)
	{
		pq->_front = pq->_tail = BuyQueueNode(x);
		return;
	}

	pq->_tail->_next = BuyQueueNode(x);
	pq->_tail = pq->_tail->_next;
}

void QueuePop(Queue* pq)
{
	QueueNode* del;
    if (pq->_front == NULL)
		return;
	if (pq->_front == pq->_tail)
	{
		pq->_tail = NULL;
	}
	del = pq->_front;
	pq->_front = pq->_front->_next;
	free(del);
}

QUDataType QueueFront(Queue* pq)
{
	return pq->_front->_data;
}

QUDataType QueueBack(Queue* pq)
{
	return pq->_tail->_data;
}

int QueueEmpty(Queue* pq)
{
	if (pq->_front != NULL)
	{
		return 1;
	}
	return 0;
}

int QueueSize(Queue* pq)
{
	QueueNode* cur = pq->_front;
	int size = 0;
	while (cur)
	{
		size++;
		cur = cur->_next;
	}
	return size;
}

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

/** Initialize your data structure here. */
MyStack* myStackCreate(int maxSize) {
    MyStack* queue = (MyStack*)malloc(sizeof(MyStack));
    QueueInit(&queue->q1);
    QueueInit(&queue->q2);
    
    return queue;
}

/** Push element x onto stack. */
void myStackPush(MyStack* obj, int x) {
    if(QueueEmpty(&obj->q1) != 0)
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }
}

/** Removes the element on top of the stack and returns that element. */
int myStackPop(MyStack* obj) {
    Queue* Empty = &obj->q1;
    Queue* NonEmpty = &obj->q2;
    if(QueueEmpty(&obj->q1) != 0)
    {
        NonEmpty = &obj->q1;
        Empty = &obj->q2;
    }
    
    while(QueueSize(NonEmpty) > 1)
    {
        QueuePush(Empty,QueueFront(NonEmpty));
        QueuePop(NonEmpty);
    }
    
    int front = QueueFront(NonEmpty);
    QueuePop(NonEmpty);
    
    return front;
}

/** Get the top element. */
int myStackTop(MyStack* obj) {
    Queue* Empty = &obj->q1;
    Queue* NonEmpty = &obj->q2;
    if(QueueEmpty(&obj->q1) != 0)
    {
        NonEmpty = &obj->q1;
        Empty = &obj->q2;
    }
    
    while(QueueSize(NonEmpty) > 1)
    {
        QueuePush(Empty,QueueFront(NonEmpty));
        QueuePop(NonEmpty);
    }
    
    int front = QueueFront(NonEmpty);
    QueuePush(Empty,QueueFront(NonEmpty));
    QueuePop(NonEmpty);
    
    return front;
}

/** Returns whether the stack is empty. */
bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->q1) == 0 && QueueEmpty(&obj->q2) == 0;
}

void myStackFree(MyStack* obj) {
    free(obj);
    
    obj = NULL;
}



/**
* Your MyStack struct will be instantiated and called as such://实现环形队列
* struct MyStack* obj = myStackCreate(maxSize);
* myStackPush(obj, x);
* int param_2 = myStackPop(obj);
* int param_3 = myStackTop(obj);
* bool param_4 = myStackEmpty(obj);
* myStackFree(obj);
*/
typedef struct {
	int* queue;
	int front;
	int rear;
	int k;
} MyCircularQueue;

/** Initialize your data structure here. Set the size of the queue to be k. */
MyCircularQueue* myCircularQueueCreate(int k) {
	MyCircularQueue* pcq = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
	pcq->queue = (int*)malloc(sizeof(int)*(k + 1));
	pcq->front = 0;
	pcq->rear = 0;
	pcq->k = k;

	return pcq;
}

/** Insert an element into the circular queue. Return true if the operation is successful. */
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
	if ((obj->rear + 1) % (obj->k + 1) == obj->front)
	{
		return false;
	}

	obj->queue[obj->rear++] = value;
	if (obj->rear == obj->k + 1)
		obj->rear = 0;

	return true;
}

/** Delete an element from the circular queue. Return true if the operation is successful. */
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
	if (obj->rear == obj->front)
	{
		return false;
	}

	++obj->front;
	if (obj->front == obj->k + 1)
	{
		obj->front = 0;
	}

	return true;
}

/** Get the front item from the queue. */
int myCircularQueueFront(MyCircularQueue* obj) {
	if (obj->rear == obj->front)
	{
		return -1;
	}
	return obj->queue[obj->front];
}

/** Get the last item from the queue. */
int myCircularQueueRear(MyCircularQueue* obj) {
	if (obj->front == obj->rear)
	{
		return -1;
	}

	if (obj->rear == 0)
	{
		return obj->queue[obj->k];
	}
	else
	{
		return obj->queue[obj->rear - 1];
	}
}

/** Checks whether the circular queue is empty or not. */
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
	return obj->front == obj->rear ? true : false;
}

/** Checks whether the circular queue is full or not. */
bool myCircularQueueIsFull(MyCircularQueue* obj) {
	return (obj->rear + 1) % (obj->k + 1) == obj->front;
}

void myCircularQueueFree(MyCircularQueue* obj) {
	free(obj);

	obj = NULL;
}

/**
* Your MyCircularQueue struct will be instantiated and called as such://最小栈的实现
* struct MyCircularQueue* obj = myCircularQueueCreate(k);
* bool param_1 = myCircularQueueEnQueue(obj, value);
* bool param_2 = myCircularQueueDeQueue(obj);
* int param_3 = myCircularQueueFront(obj);
* int param_4 = myCircularQueueRear(obj);
* bool param_5 = myCircularQueueIsEmpty(obj);
* bool param_6 = myCircularQueueIsFull(obj);
* myCircularQueueFree(obj);
*/typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;
	int _capacity;
}Stack;

void StackInit(Stack* ps)
{
	assert(ps);
	ps->_a = NULL;
	ps->_capacity = 0;
	ps->_top = 0;
}

void StackDestory(Stack* ps)
{
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_capacity = 0;
	ps->_top = 0;
}

void StackPush(Stack* ps, STDataType x)
{
	assert(ps);
	if (ps->_top == ps->_capacity)
	{
		size_t newcapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		ps->_a = (STDataType*)realloc(ps->_a, sizeof(STDataType)*newcapacity);
		assert(ps->_a != NULL);
		ps->_capacity = newcapacity;
	}

	ps->_a[ps->_top] = x;
	ps->_top++;
}

void StackPop(Stack* ps)
{
	assert(ps && ps->_top > 0);
	--ps->_top;
}

STDataType StackTop(Stack* ps)
{
	assert(ps && ps->_top > 0);
	return ps->_a[ps->_top - 1];
}

int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->_top == 0 ? 0 : 1;
}

int StackSize(Stack* ps)
{
	assert(ps);
	return ps->_top;
}
typedef struct {
	Stack st;
	Stack Minst;
} MinStack;

/** initialize your data structure here. */
MinStack* minStackCreate(int maxSize) {
	MinStack* pst = (MinStack*)malloc(sizeof(MinStack));
	StackInit(&pst->st);
	StackInit(&pst->Minst);

	return pst;
}

void minStackPush(MinStack* obj, int x) {
	if (StackEmpty(&obj->Minst) == 0 || x <= StackTop(&obj->Minst))
	{
		StackPush(&obj->Minst, x);
	}

	StackPush(&obj->st, x);
}

void minStackPop(MinStack* obj) {
	if (StackTop(&obj->st) == StackTop(&obj->Minst))
	{
		StackPop(&obj->Minst);
	}

	StackPop(&obj->st);
}

int minStackTop(MinStack* obj) {

	return StackTop(&obj->st);
}

int minStackGetMin(MinStack* obj) {
	return StackTop(&obj->Minst);
}

void minStackFree(MinStack* obj) {
	StackDestory(&obj->st);
	StackDestory(&obj->Minst);

	obj = NULL;
}

/**
* Your MinStack struct will be instantiated and called as such://使用栈实现队列
* struct MinStack* obj = minStackCreate(maxSize);
* minStackPush(obj, x);
* minStackPop(obj);
* int param_3 = minStackTop(obj);
* int param_4 = minStackGetMin(obj);
* minStackFree(obj);
*/
typedef int STDataType;
typedef struct Stack
{
	STDataType* _a;
	int _top;
	int _capacity;
}Stack;

void StackInit(Stack* ps)
{
	assert(ps);
	ps->_a = NULL;
	ps->_capacity = 0;
	ps->_top = 0;
}

void StackDestory(Stack* ps)
{
	assert(ps);
	free(ps->_a);
	ps->_a = NULL;
	ps->_capacity = 0;
	ps->_top = 0;
}

void StackPush(Stack* ps, STDataType x)
{
	assert(ps);
	if (ps->_top == ps->_capacity)
	{
		size_t newcapacity = ps->_capacity == 0 ? 4 : ps->_capacity * 2;
		ps->_a = (STDataType*)realloc(ps->_a, sizeof(STDataType)*newcapacity);
		assert(ps->_a != NULL);
		ps->_capacity = newcapacity;
	}

	ps->_a[ps->_top] = x;
	ps->_top++;
}

void StackPop(Stack* ps)
{
	assert(ps && ps->_top > 0);
	--ps->_top;
}

STDataType StackTop(Stack* ps)
{
	assert(ps && ps->_top > 0);
	return ps->_a[ps->_top - 1];
}

int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->_top == 0 ? 0 : 1;
}

int StackSize(Stack* ps)
{
	assert(ps);
	return ps->_top;
}
typedef struct {
	Stack Pushst;
	Stack Popst;
} MyQueue;

/** Initialize your data structure here. */
MyQueue* myQueueCreate(int maxSize) {
	MyQueue* queue = (MyQueue*)malloc(sizeof(MyQueue));
	StackInit(&queue->Pushst);
	StackInit(&queue->Popst);

	return queue;
}

/** Push element x to the back of queue. */
void myQueuePush(MyQueue* obj, int x) {
	StackPush(&obj->Pushst, x);
}

/** Removes the element from in front of queue and returns that element. */
int myQueuePop(MyQueue* obj) {
	if (StackEmpty(&obj->Popst) == 0)
	{
		while (StackEmpty(&obj->Pushst) != 0)
		{
			StackPush(&obj->Popst, StackTop(&obj->Pushst));
			StackPop(&obj->Pushst);
		}
	}
	int front = StackTop(&obj->Popst);
	StackPop(&obj->Popst);

	return front;
}

/** Get the front element. */
int myQueuePeek(MyQueue* obj) {
	if (StackEmpty(&obj->Popst) == 0)
	{
		while (StackEmpty(&obj->Pushst) != 0)
		{
			StackPush(&obj->Popst, StackTop(&obj->Pushst));
			StackPop(&obj->Pushst);
		}
	}

	return StackTop(&obj->Popst);
}

/** Returns whether the queue is empty. */
bool myQueueEmpty(MyQueue* obj) {
	return StackEmpty(&obj->Pushst) == 0
		&& StackEmpty(&obj->Popst) == 0;
}

void myQueueFree(MyQueue* obj) {
	StackDestory(&obj->Pushst);
	StackDestory(&obj->Popst);

	obj = NULL;
}

/**
* Your MyQueue struct will be instantiated and called as such:
* struct MyQueue* obj = myQueueCreate(maxSize);
* myQueuePush(obj, x);
* int param_2 = myQueuePop(obj);
* int param_3 = myQueuePeek(obj);
* bool param_4 = myQueueEmpty(obj);
* myQueueFree(obj);
*/
lucky52529
关注
专栏目录
【面试题】栈和队列的面试题
皓皓松的博客
02-20 2394
题目一：实现一个栈，要求其入栈，出栈，返回最小值的时间复杂度为O(1) 这道题目，主要问题在于如何时查找最小元素的时间复杂度为O(1)，这里我们先想到了用一个变量存取最小值 在仅仅入栈时，我们可以通过该MinElem这个变量来查找最小值是完全没有问题的； 但是，如果我们进行出栈，并且把该最小值出栈后，那最小值是不是就找不到了； 下面是正确的解法： 这里我们要用两个栈，第一
栈和队列的面试题
小葱的博客
07-13 1071
1.实现一个栈，要求实现Push（出栈）、Pop（入栈）、Min（返回最小值的操作）的时间复杂度为O(1)对于这个问题，我们都知道，栈的入栈和出栈时间复杂度都是O(1),那么我们所面临的问题就是需要有一个接口来实现返回最小值的操作，且这个操作的时间复杂度必须是O(1)。 这里有两种思路可供选择： （1）前提：这里有一组数据，利用一个栈，将这些数据需要入栈，而在入栈的时候遵循这样的规律，将一个数据
栈和队列面试题
Calm的博客
08-25 301
我们在来看今天的代码之前，相信大家以前可能都封装过栈和队列的基本操作，所以我们在用到一些栈和队列的基本操作的时候，只需要把栈和队列的头文件引进来就可以调用它的一些基本操作的函数，就不用再把那些函数再写一遍了，但在调用栈和队列的头文件的时候，我们必须把栈和队列的头文件和源文件复制到当前这个项目工程底下，不然调不过来。 那我也把栈和队列的那些基本函数给大家放在这吧，便于理解。 Stack.h ...
栈和队列的面试题(一)
virgofarm的博客
05-04 291
一：实现一个栈，要求实现Push(出栈)、Pop(入栈)、Min(返回最小值)的时间复杂度为O(1) 方法一： 思路：这里我们栈底层采用的是静态顺序表实现，出栈、入栈我们都很容易实现时间复杂度为O(1)，但是，要返回最小值，按照我们常规的思路，遍历栈，可以得出最小值，但是时间复杂度为O(n),不符合题目要求，我们可以在栈中每次放入两个数据，一个是本来就要放的data,另一个为Mindata...
Java实现栈和队列面试题
09-03
以上就是Java实现栈和队列面试题的主要内容。理解和熟练掌握这些知识点对于Java开发者来说至关重要，因为它们涉及到基础数据结构的运用，能够反映候选人在解决实际问题时的逻辑思维和算法能力。在面试中，候选人可能...
栈与队列面试题解析：从基础到高级应用
"3栈和队列面试题精讲.ppt" 这篇内容主要讲解了与栈和队列相关的面试题目，并提供了详细的解题思路。栈和队列是两种基础且重要的线性数据结构，它们在算法和数据结构领域扮演着至关重要的角色。 线性表是一种简单...
栈与队列面试题详解：从基础到高级应用
"栈和队列是数据结构中的基础概念，常常出现在面试题中，用于考察程序员对数据结构的理解和应用能力。本文由七月算法的曹鹏于2015年4月23日撰写，主要讲解了与栈和队列相关的面试题目，并通过实例进行解析，帮助读者...
3栈和队列面试题精讲.ppt
07-31
3栈和队列面试题精讲
（剑指offer）面试题09. 用两个栈实现队列
12-21
在本题中，我们需要使用两个栈来模拟队列的行为。 题目要求我们实现一个类`CQueue`，它有两个主要方法：`appendTail`用于在队列尾部插入元素，`deleteHead`用于从队列头部删除元素并返回该元素。如果队列为空，`...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值