26-队列练习-LeetCode225用队列实现栈

Posted hyperNZ

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了26-队列练习-LeetCode225用队列实现栈相关的知识,希望对你有一定的参考价值。

题目 

请你仅使用两个队列实现一个后入先出(LIFO)的栈,并支持普通栈的全部四种操作(push、top、pop 和 empty)。

实现 MyStack 类:

    void push(int x) 将元素 x 压入栈顶。
    int pop() 移除并返回栈顶元素。
    int top() 返回栈顶元素。
    boolean empty() 如果栈是空的,返回 true ;否则,返回 false 。

注意:

你只能使用队列的基本操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。

你所使用的语言也许不支持队列。 你可以使用 list (列表)或者 deque(双端队列)来模拟一个队列 , 只要是标准的队列操作可。

示例:

输入:
["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]
输出:
[null, null, null, 2, 2, false]

解释:
MyStack myStack = new MyStack();
myStack.push(1);
myStack.push(2);
myStack.top(); // 返回 2
myStack.pop(); // 返回 2
myStack.empty(); // 返回 False

提示:

    1 <= x <= 9
    最多调用100 次 push、pop、top 和 empty
    每次调用 pop 和 top 都保证栈不为空

进阶:你能否仅用一个队列来实现栈。


思路1:用2个队列实现一个栈:

  • q1队列:添加元素之后存储具体元素的队列。
  • q2队列:作为辅助队列,每次添加元素之后保证q2为空。

元素先入q2,然后将q1的元素出队再入q2,再让q1与q2互换名字。


代码1

class MyStack 
    //q1永远是保存元素的队列
    private Queue<Integer> queue1;
    //q2永远保持为空,为辅助队列
    private Queue<Integer> queue2;

    public MyStack() 
        this.queue1 = new LinkedList<>();
        this.queue2 = new LinkedList<>();
    
    
    public void push(int x) 
        queue2.offer(x);
        //将q1的所有元素依次出队列而后入q2
        while(!queue1.isEmpty()) 
            queue2.offer(queue1.poll());
        
        //此时q1为空,q2存元素,q1与q2互换名字
        Queue<Integer> tmp = queue1;
        queue1 = queue2;
        queue2 = tmp;
    
    
    public int pop() 
        return queue1.poll();
    
    
    public int top() 
        return queue1.peek();
    
    
    public boolean empty() 
        return queue1.isEmpty();
    


/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * boolean param_4 = obj.empty();
 */

思路2:用一个队列实现一个栈

  1. 先获取当前队列中元素个数n
  2. 将元素入队
  3. 将队列中之前的n个元素出队
  4. 将出队的n个元素依次入队

(边出边入)


代码2

class MyStack 
    private Queue<Integer> queue;

    public MyStack() 
        queue = new LinkedList<>();
    
    
    public void push(int x) 
        //获取当前队列元素个数
        int n = queue.size();
        //先入队
        queue.add(x);
        //将前n个元素依次出队再入队
        for(int i = 0; i < n; i++) 
            queue.add(queue.poll());
        
    
    
    public int pop() 
        return queue.poll();
    
    
    public int top() 
        return queue.peek();
    
    
    public boolean empty() 
        return queue.isEmpty();
    


/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * boolean param_4 = obj.empty();
 */

数据结构栈和队列OJ练习(栈和队列相互实现+循环队列实现)

目录

前言

1.用队列实现栈

2.用栈实现队列

3.循环队列


前言

前面在学习了栈和队列的实现之后,相信大家对栈和队列的结构和使用方式都有了一些理解。

下面我们就来进行一些练习,这这章的练习相对于原来在难度上有了一些提升。

原来的题只需要实现一个接口,而今天的练习题需要实现多个接口。

1.用队列实现栈

225. 用队列实现栈 - 力扣(LeetCode) (leetcode-cn.com)

栈:后进先出队列:先进先出 

方法:

创建两个队列,用来来回导数据。

入栈:将数据放入不为空的队列。

出栈:将不为空的队列中的数据以出队入栈的方式放入空队列,直到该队列中只剩一个数据。

           这个数据就是要出栈的数据,直接将他pop掉即可。

栈顶:返回队尾。

检测栈是否为空:两个队列都为空,则栈为空。

口说无凭,请看图:

如图:

队列1中有4个数,以1,2,3,4顺序入队,所以1为队头,4为队尾。

根据队列先进先出规则,1应该先出队。而这里我们要实现栈,即后进先出,即应该先出队尾数据。

所以我们将除队尾数据全部先导入队列2中,这样队列1中就只剩下队尾数据。

注意:队列1中的数据导入队列2中后,数据的相对位置是不变的。

即:

最后出栈,就可得到栈顶数据。

代码如下:

typedef int QDataType;
typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType data;
}QueueNode;

typedef struct Queue
{
	QueueNode* head;
	QueueNode* tail;
}Queue;

//初始化
void QueueInit(Queue* pq);

//销毁
void QueueDestroy(Queue* pq);

//入队
void QueuePush(Queue* pq, QDataType x);

//出队
void QueuePop(Queue* pq);


QDataType QueueFront(Queue* pq);

QDataType QueueBack(Queue* pq);

bool QueueEmpty(Queue* pq);

int QueueSize(Queue* pq);


//初始化
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}

//销毁
void QueueDestroy(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->head;
	while (cur)
	{
		QueueNode* next = cur->next;
		free(cur);
		cur = next;
	}
}

//入队
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QueueNode* newnode = (QueueNode*)malloc(sizeof(QueueNode));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->head == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}

//出队
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	QueueNode* next = pq->head->next;
	free(pq->head);
	
	pq->head = next;
	if (pq->head == NULL)
	{
		pq->tail = NULL;
	}
	
}


QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->head->data;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->tail->data;
}

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL;
}

int QueueSize(Queue* pq)
{
	assert(pq);
	QueueNode* cur = pq->head;
	int size = 0;
	while (cur)
	{
		size++;
		cur = cur->next;
	}
	return size;
}
//因为C语言中没有直接可以调用的栈和队列,所以需要将自己实现的队列拷贝到前面


typedef struct {//在栈中创建两个队列
    Queue q1;
    Queue q2;
} MyStack;

bool myStackEmpty(MyStack* obj);
MyStack* myStackCreate() {
    MyStack*obj = (MyStack*)malloc(sizeof(MyStack));//动态开辟存放两个队列结构体
    QueueInit(&obj->q1);//初始化两个队列
    QueueInit(&obj->q2);
    return obj;//需返回该结构体地址
}

void myStackPush(MyStack* obj, int x) {
    if(!QueueEmpty(&obj->q1))//入栈时向不为空的队列插入数据,都为空这里默认向队列2中插入
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }
    
}

int myStackPop(MyStack* obj) {
    Queue*empty = &obj->q1;//出栈时需在不为空的队列里出,所以先找不为空的队列
    Queue*noempty = &obj->q2;//默认队列1不为空
    if(!QueueEmpty(&obj->q1))//如果队列1不为空,则交换两队列
    {
        empty = &obj->q2;
        noempty = &obj->q1;
    }
    while(QueueSize(noempty)>1)//将不为空队列中除队尾数据全部放入空队列中
    {
        QueuePush(empty,QueueFront(noempty));
        QueuePop(noempty);
    }
    int pop = QueueFront(noempty);//剩下的最后一个数据
    QueuePop(noempty);//将数据Pop掉
    return pop;
}

int myStackTop(MyStack* obj) {//返回不为空的队列的队尾
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else
    {
        return QueueBack(&obj->q2);
    }
}

bool myStackEmpty(MyStack* obj) {//两个队列都为空则栈为空
    return QueueEmpty(&obj->q1)&&QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q1);//不要忘记销毁两个队列
    QueueDestroy(&obj->q2);
    free(obj);
}

2.用栈实现队列

232. 用栈实现队列 - 力扣(LeetCode) (leetcode-cn.com)

方法:

与上题类似,创建两个栈,将数据入栈与入队相同。栈1用来入数据,栈2用来出数据。

不过出队时,队头的数据位于栈底,所以还是要将除栈底的数据全部导入另一个栈中。

但不同的是,队列实现栈时,导过去后数据的顺序不变,所以需要来回导;而这里倒过去后数据顺序会颠倒,所以不需要再导回去,可以直接出队,直到该栈中没有数据。

口说无凭,请看图:

这样下一次再需要出队时,只需将栈2的栈顶Pop即可,直到栈2中没有数据,然后再从栈1中导数据。

代码如下:

typedef int STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}Stack;

//初始化
void StackInit(Stack*ps);

//销毁
void StackDestroy(Stack* ps);

//压栈
void StackPush(Stack* ps, STDataType x);

//出栈
void StackPop(Stack* ps);

//栈顶
STDataType StackTop(Stack* ps);

//判断栈是否为空
bool StackEmpty(Stack* ps);

//栈中元素个数
int StackSize(Stack* ps);


void StackInit(Stack* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = ps->top = 0;
}

void StackPush(Stack* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a , sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc");
			exit(-1);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}


void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
}

STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a[ps->top - 1];
}

bool StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->top == 0;
}


int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}
//同样需拷贝自己实现的栈



typedef struct {//创建两个栈,s1用来入数据,s2用来出数据
    Stack s1;
    Stack s2;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue*obj = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&obj->s1);
    StackInit(&obj->s2);
    return obj;
}

void myQueuePush(MyQueue* obj, int x) {
    StackPush(&obj->s1,x);//直接将数据Push到s1中
}

int myQueuePop(MyQueue* obj) {
    if(StackEmpty(&obj->s2))//pop数据之前先检查s2中是否有数据,没有数据需从s1中导入
    {
        while(!StackEmpty(&obj->s1))
        {
            StackPush(&obj->s2,StackTop(&obj->s1));
            StackPop(&obj->s1);
        }
    }
    int pop = StackTop(&obj->s2);//直接pop栈顶数据即可
    StackPop(&obj->s2);
    return pop;
}

int myQueuePeek(MyQueue* obj) {//返回队尾数据(即s2栈顶数据)
    if(StackEmpty(&obj->s2))//返回数据之前先检查s2中是否有数据,没有数据需从s1中导入
    {
        while(!StackEmpty(&obj->s1))
        {
            StackPush(&obj->s2,StackTop(&obj->s1));
            StackPop(&obj->s1);
        }
    }
    return StackTop(&obj->s2);
}

bool myQueueEmpty(MyQueue* obj) {//两个栈都为空,队列才为空
    return StackEmpty(&obj->s1)&&StackEmpty(&obj->s2);
}

void myQueueFree(MyQueue* obj) {
    StackDestroy(&obj->s1);
    StackDestroy(&obj->s2);
    free(obj);
}

3.循环队列

622. 设计循环队列 - 力扣(LeetCode) (leetcode-cn.com)

这道题的意思是:

设计一个队列,这个队列的大小是固定的,且队列头尾相连, 然后该队列能够实现题目中的操作。

那么是使用数组实现,还是用链表实现呢?我们接着往下看。

例如:用k表示数组大小

图中我们用数组实现。用head和tail表示队头队尾下标,每插入一个数据,在数组tail位置插入,然后再将tail++。

但是有个问题如果将head==tail认为是队列为空的条件,那么怎么判断队列满了呢?

面对这个问题我们这样解决:将数组的空间大小增加1,即数组比队列大1个空间。

这样:当 head = tail 时队列为空,(tail+1)%(k+1) = head 时队列满了。

且以链表实现时也会多申请一个空间。

代码如下:数组实现

typedef struct {
    int*arr;
    int head;//队头
    int tail;//队尾
    int capacity;//队列容量
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue*obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->arr = (int*)malloc(sizeof(int)*(k+1));//申请数组空间
    obj->head = 0;
    obj->tail = 0;
    obj->capacity = k;//队列大小
    return obj;
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);

//插入数据
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))//检查容量
    {
        return false;
    }
    else
    {
        obj->arr[obj->tail] = value;//在队尾位置插入
        obj->tail++;//队尾向后移动
        obj->tail %= obj->capacity+1;//当队尾移动到数组最后一个元素后面的下标时,队尾回到数组下标为0的位置 
        return true;
    }
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))//检测队列是否为空
    {
        return false;
    }
    else
    {
        obj->head++;
        obj->head %= obj->capacity+1; 当队头移动到数组最后一个元素后面的下标时,队尾回到数组下标为0的位置 

        return true;

    }

}

int myCircularQueueFront(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;//队列为空返回-1
    }
    else
    {
        return obj->arr[obj->head];//返回队头数据
    }
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;//队列为空返回-1
    }
    else
    {
        return obj->arr[(obj->tail+obj->capacity)%(obj->capacity+1)];//返回下标为tail位置前面一个位置数据
    }
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->head == obj->tail;//head==tail队列为空
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->tail+1)%(obj->capacity+1) == obj->head;//为防止数组越界,不能直接将tail+1与head比较
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->arr);
    free(obj);
}

链表实现与数组实现类似,只是判断队列满的条件的不一样。

链表判满的条件时tail->next = head;

代码如下:

typedef struct ListNode1 ListNode1;
struct ListNode1{
    int data;
    ListNode1* next;
};


typedef struct {
    ListNode1* front;//创建头尾指针指向队列头和尾
    ListNode1* tail;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->front = NULL;
    ListNode1* cur = NULL;
    while (k > -1)//创建k+1个结点
    {
        if (obj->front == NULL)
        {
            obj->front = (ListNode1*)malloc(sizeof(ListNode1));
            obj->front->next = NULL;
            cur = obj->front;
        }
        else
        {
            ListNode1* next = (ListNode1*)malloc(sizeof(ListNode1));
            cur->next = next;
            cur = next;
        }
        k--;
    }
    cur->next = obj->front;//将链表成环
    obj->tail = obj->front;//头尾指针复位
    return obj;
}


bool myCircularQueueIsEmpty(MyCircularQueue* obj);
bool myCircularQueueIsFull(MyCircularQueue* obj);

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if (myCircularQueueIsFull(obj))
    {
        return false;
    }
    else
    {
        obj->tail->data = value;//插入数据将数据放入tail结点
        obj->tail = obj->tail->next;//tail结点向后移动
        return true;
    }
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return false;
    }
    else
    {
        obj->front = obj->front->next;//删除数据时直接将头指针向后移动,不用将该位置的数据删除
        return true;
    }
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        return obj->front->data;//返回头指针结点处的数据
    }
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if (myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    {
        ListNode1* cur = obj->front;//因为不知到队尾位置,只知道队尾的下一个位置,所以需要遍历链表寻找队尾。
        while (cur->next != obj->tail)
        {
            cur = cur->next;
        }
        return cur->data;
    }
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->front == obj->tail;//head==tail队列为空
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return obj->tail->next == obj->front;//tail->next == head 队列满了
}

void myCircularQueueFree(MyCircularQueue* obj) {
    ListNode1* cur = obj->front->next;
    while (cur != obj->front)//释放链表结点
    {
        ListNode1* next = cur->next;
        free(cur);
        cur = next;
    }
    free(cur);
    free(obj);
}

如有错误,或更好的方法,可以在评论区一起交流哟~

你的点赞支持就是我创作的动力!

以上是关于26-队列练习-LeetCode225用队列实现栈的主要内容,如果未能解决你的问题,请参考以下文章

LeetCode Algorithm 225. 用队列实现栈

LeetCode--225--用队列实现栈

[LeetCode] 225. 用队列实现栈

⭐算法入门⭐《栈 和 队列》简单02 —— LeetCode 225. 用队列实现栈

leetcode-225-用队列实现栈

leetcode225. 用队列实现栈