算法-下压栈

下压栈是一种基于后进先出(LIFO)的策略

例子：

实际生活中：将你的邮件在桌子上放成一叠时，使用的就是栈，因为每次取得的都是最后的那一封

计算机中：许多人仍然使用栈的方式存放电子邮件---在收信时将邮件压入(push)最顶端，在取信时从最顶端将他们弹出(pop)，且第一封一定是最新的邮件(因为栈的策略是后进先出)

这种策略的好处是：我们能够即时的看到感兴趣的邮件

坏处是：如果不把栈清空，某些较早的邮件可能永远都不会阅读

浏览器：点击一个超链接，浏览器会显示一个新的页面(并将它压入一个栈)。你可以不断的点击超链接访问新页面，但总是可以通过“回退”按钮重新访问以前的页面(从栈中弹出)

注意：当用例使用foreach语句迭代遍历栈中的元素时，元素的处理顺序和他们被压入的顺序正好相反

package base.第一章.背包_队列_和栈.下压栈;

import java.util.Iterator;

/**
 * Created by MK on 2018/7/19.
 * 创建栈(Stack)---以链表的方式实现
 * public class Stack<Item> implements Iterable<Item>
 * Stack()                     创建一个空栈
 * void push(Item item)        添加一个元素
 * Item pop()                  删除最近添加的元素
 * boolean isEmpty()           栈是否为空
 * int size()                  栈中的元素数量
 */
public class Stack<Item> implements Iterable<Item> {

    private Node<Item> node; //创建头节点
    private int n;


    //定义节点的嵌套类
    private class Node<Item> {
        Item item;  //所传参数的值
        Node next;  //节点的指针
    }

    public boolean isEmpty() {
        return node.next == null;
    }

    public int size() {
        return n;
    }

  public void push(Item item) {
        Node oldNode = node; //此时的节点变成了老节点
        node = new Node<Item>(); //创建新节点

        node.item = item; //将值赋值给新节点
        node.next = oldNode;  //新节点的下标指向的是老节点
        n++;
    }

   public Item pop() {
        Item item = node.item;
        node = node.next; //跳过节点
        n--;
        return item;
    }

    //实现迭代
    @Override
    public Iterator<Item> iterator() {
        return new ListIterator();
    }

    private class ListIterator implements Iterator<Item> {
        private Node current = node;

        public boolean hasNext() {
            return current != null;
        }

        public Item next() {
            Item item = (Item) current.item;
            current = current.next;
            return item;
        }
    }
}

package base.第一章.背包_队列_和栈.下压栈;

import edu.princeton.cs.algs4.StdOut;

/**
 * Created by MK on 2018/7/19.
 * 测试Stack
 */
public class 下压栈测试 {

    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<Integer>();

        stack.push(32);
        stack.push(1);
        stack.push(21);
        stack.push(3); //3是最后放入的，类似于放在桌面上的邮件，其是最后一封

        stack.pop(); //栈的删除，删除的是最后放入的

        //foreach循环 栈的话，输出顺序与被压入的顺序正好相反。例如上面的测试例子：32是最先压入的，那么循环的话32就在最底层显示
        for (Integer res : stack) {
            StdOut.println(res);
        }
    }
}

猜你喜欢