数据结构----------堆栈、队列补充

1. 两个队列实现一个栈

基本思想：（总保证一个队列的数据为空）

　　　　压栈：永远将数据添加到非空队列。

　　　　弹栈：将n-1个元素出队，并添加到另外一个空的队列，然后poll第n个元素。

代码实现

import java.util.LinkedList;
import java.util.Queue;
/**
 * 
 *基于两个队列实现一个栈
 * @param <Item>
 */
public class Stack<Item> {
    private Queue<Item> queue1 = new LinkedList<>();
    private Queue<Item> queue2 = new LinkedList<>();
    /**
     * 添加元素，每次都往不为空的队列中添加元素
     * @param item
     */
    public void push(Item item) {
        if(queue1.isEmpty()) {
            queue2.add(item);
            return;
        }
        if(queue2.isEmpty()) {
            queue1.add(item);
        }
    }
    
    
    /**
     * 弹出一个元素
     * @return
     */
    public Item pop() {
        if(queue1.isEmpty() && queue2.isEmpty()) {//如果俩个队列的数据都为空，刨出异常
            throw new RuntimeException("栈为空");
        }else if(queue1.isEmpty()) {//如果queue1为空，
            //将queue2的n-1个元素添加queue1
            while(queue2.size() > 1) {
                queue1.add(queue2.poll());
            }
            //返回queue2的最后一个元素
            return queue2.poll();
        }else {//如果queue2为空
            //将queue1的n-1个元素添加的哦quque2
            while(queue1.size() > 1) {
                queue2.add(queue1.poll());
            }
            //返回queue1的最后一个元素
            return queue1.poll();
        }        
    }
}

2. 两个栈实现一个队列

基本思想

　　入队：总是往第一个栈中添加数据

　　出队：如果第二个栈数据不为空，咱弹栈元素即出队元素；如果第二栈的数据为空，则将n-1个元素弹出，并添加到第二个队列，然后弹出第一个栈的最后一个元素

代码实现

import java.util.Stack;
/**
 * 两个栈实现一个队列
 * @author Administrator
 *
 * @param <Item>
 */
public class Queue<Item> {
    private Stack<Item> stack1 = new Stack<>();
    private Stack<Item> stack2 = new Stack<>();
    
    /**
     * 入队 ：全部添加到第一个栈
     * @param item
     */
    public void enqueue(Item item) {
        stack1.push(item);
    }
    
    /**
     * 出队：
     * @return
     */
    public Item dequeue() {
        if(stack2.size() != 0) {//如果第二个栈不为空，直接弹出
            return stack2.pop();
        }else if(stack1.size() != 0) {//如果第二个栈为空，第一个栈不为空
            //将n-1个元素压入第二个栈
            while(stack1.size() > 1) {
                stack2.push(stack1.pop());
            }
            //返回第一个栈的 最后一个元素
            return stack1.pop();
        } else {//如果两个栈的数据 都为空
            throw new RuntimeException("队列为空");
        }
    }
}

3. 实现一个能够返回最小元素的栈

　　设计含最小函数min()的栈，要求min、push、pop、的时间复杂度都是O(1)。min方法的作用是：就能返回是栈中的最小值。

基本思想

　　一般情况下，我们可能会这么想：利用min变量，每次添加元素时，都和min元素作比较，这样的话，就能保证min存放的是最小值。但是这样的话，会存在一个问题：如果最小的元素出栈了，那怎么知道剩下的元素中哪个是最小的元素呢？

　　改进思路：

　　这里需要加一个辅助栈，用空间换取时间。辅助栈中，栈顶永远保存着当前栈中最小的数值。具体是这样的：原栈中，每次添加一个新元素时，就和辅助栈的栈顶元素相比较，如果新元素小，就把新元素的值放到辅助栈和原栈中，如果新元素大，就把元素放到原栈中；出栈时，如果原栈跟辅助栈元素相同，都弹出，否则只弹出原栈栈顶元素

代码实现

import java.util.Stack;

public class MinStack<Item extends Comparable<Item>> {
    private Stack<Item> stack1 = new Stack<>();
    private Stack<Item> stackMin = new Stack<>();
    
    /**
     * 添加元素
     * @param item
     */
    public void push(Item item) {
        if(stack1.isEmpty()) {
            stack1.push(item);
            stackMin.push(item);
        }else {
            Item minItem = stackMin.peek();
            if(item.compareTo(minItem) < 0) {
                stackMin.push(item);
            }
            stack1.push(item);
        }
    }
    
    public Item pop() {
        if(stack1.isEmpty()) {
            throw new RuntimeException("栈为空");
        }
        if(stack1.peek().compareTo(stackMin.peek()) == 0) {
            stackMin.pop();
        }
        return stack1.pop();
        
    }
    
    /**
     * 返回最小元素
     * @return
     */
    public Item min() {
        if(stackMin.isEmpty()) {
            throw new RuntimeException("栈为空");
        }
        
        return stackMin.peek();
    }
}

数据结构----------堆栈、队列补充

猜你喜欢