04 两个栈构造队列 & 两个队列构造栈

前言

本博文部分图片, 思路来自于剑指offer 或者编程珠玑

问题描述

利用两个栈构造一个队列, 使用两个队列构造一个栈

思路

两个栈构造队列 : 一个栈作为存储数据的栈, 另一个栈作为业务栈, 入队 : 直接向存储栈添加数据, 出队 : 如果业务栈为空 则将存储栈中的数据倒入业务栈, 如果此时业务占仍然为空 返回null

两个队列构造栈 :

思路一 : 一个队列作为业务队列, 一个队列作为临时存储队列, 入栈 : 将数据存储在业务队列中, 出栈 : 将业务队列的数据的 前(size-1)个数据移到tmp队列中, 在讲业务队列中的最后一个元素出队, 最后将tmp队列中的所有元素移动到业务队列中

思路二 : 一个队列作为业务队列, 一个队列作为临时存储队列, 入栈 : 将数据存储在业务队列中, 出栈 : 将业务队列的数据的 前(size-1)个数据移到tmp队列中, 在讲业务队列中的最后一个元素出队 再交换business, tmp, 从而达到比上面一种方法少移动tmp到buiness中的过程了

参考代码

/**
* file name : Test25TwoStackToQueueAndTwoQueueToStack.java
* created at : 8:22:18 PM Jun 4, 2015
* created by 970655147
*/

package com.hx.test04;

public class Test25TwoStackToQueueAndTwoQueueToStack {

// 两个栈实现一个队列, 两个队列实现一个栈
public static void main(String[] args) {

//      Queue01 que = new Queue01();
//      Stack01 stack = new Stack01();
Stack02 stack = new Stack02();
for(int i=0; i<10; i++) {
//          que.enqueue(i);
stack.push(i);
}
//      while(!que.empty()) {
//          Log.log(que.dequeue() );
//      }
while(!stack.empty()) {
Log.log(stack.pop() );
}

}

// 基础的栈
static class Stack {
Deque<Integer> deque;

public Stack() {
deque = new LinkedList<Integer>();
}

public void push(Integer ele) {
deque.push(ele);
}

public Integer pop() {
return deque.pop();
}

public boolean empty() {
return deque.size() == 0;
}

// 将src中的对象移入dst中
public static void moveTo(Stack src, Stack dst, int size) {
if(size > src.size()) {
throw new RuntimeException("have no such many elements in src..");
}

for(int i=0; i<size; i++) {
dst.push(src.pop() );
}
}

public int size() {
return deque.size();
}
}

// 基础的队列
static class Queue {
Deque<Integer> deque;

public Queue() {
deque = new LinkedList<Integer>();
}

public void enqueue(Integer ele) {
deque.addLast(ele);
}

public Integer dequeue() {
return deque.poll();
}

// 将src中的对象移入dst中
public static void moveTo(Queue src, Queue dst, int size) {
if(size > src.size()) {
throw new RuntimeException("have no such many elements in src..");
}

for(int i=0; i<size; i++) {
dst.enqueue(src.dequeue() );
}
}

// 判断队列是否为空
private boolean empty() {
return deque.size() == 0;
}

public int size() {
return deque.size();
}
}

// 利用两个栈实现的队列
// 思路 : 一个栈作为存储数据的栈, 另一个栈作为业务栈
// 入队 : 直接向存储栈添加数据
// 出队 : 如果业务栈为空  则将存储栈中的数据倒入业务栈, 如果此时业务占仍然为空   返回null
static class Queue01 {
Stack store;
Stack business;

public Queue01() {
store = new Stack();
business = new Stack();
}

public void enqueue(Integer ele) {
store.push(ele);
}

public Integer dequeue() {
if(business.empty() ) {
Stack.moveTo(store, business, store.size());
}
if(business.empty() ) {
return null;
}

return business.pop();
}

public boolean empty() {
return business.empty() && store.empty();
}

}

// 两个队列实现一个栈  略麻烦
// 思路 : 一个队列作为业务队列, 一个队列作为临时存储队列
// 入栈 : 将数据存储在业务队列中
// 出栈 : 将业务队列的数据的 前(size-1)个数据移到tmp队列中, 在讲业务队列中的最后一个元素出队, 最后将tmp队列中的所有元素移动到业务队列中
static class Stack01 {
Queue business;
Queue tmp;

public Stack01() {
business = new Queue();
tmp = new Queue();
}

public void push(Integer ele) {
business.enqueue(ele);
}

public Integer pop() {
Queue.moveTo(business, tmp, business.size()-1);
Integer res = business.dequeue();
Queue.moveTo(tmp, business, tmp.size());
return res;
}

public boolean empty() {
return business.size() == 0;
}
}

// 两个队列实现一个栈
// 思路 : 一个队列作为业务队列, 一个队列作为临时存储队列
// 入栈 : 将数据存储在业务队列中
// 出栈 : 将业务队列的数据的 前(size-1)个数据移到tmp队列中, 在讲业务队列中的最后一个元素出队  再交换business, tmp
// 从而达到比上面一种方法少移动tmp到buiness中的过程了
static class Stack02 {
Queue business;
Queue tmp;

public Stack02() {
business = new Queue();
tmp = new Queue();
}

public void push(Integer ele) {
business.enqueue(ele);
}

public Integer pop() {
Queue.moveTo(business, tmp, business.size()-1);
Integer res = business.dequeue();

Queue tmp0 = tmp;
tmp = business;
business = tmp0;
return res;
}

public boolean empty() {
return business.size() == 0;
}

public static void swap(Queue que01, Queue que02) {
Queue tmp = que01;
que01 = que02;
que02 = tmp;
}
}

}

效果截图

总结

其实对于两个栈实现一个队列还可以[而且 比较巧妙], 但是对于两个队列构造一个栈, 似乎就没有太大的必要了, 开销太大了

注 : 因为作者的水平有限，必然可能出现一些bug, 所以请大家指出！