数据结构与算法之基础算法——栈、队列

博客目的——帮助读者理解栈、队列的概念以及算法的实现

一、开篇说明

        今天给大家带来的算法第四版的基础算法——栈和队列，作为一个java web开发，相信相同立场的阅读者都应该知道我们会很少接触到这些东西，但是作为程序员对基础算法还是要有扎实的掌握，提升自我内功的修炼，顺便应付应付面试^-^

二、数据结构

2.1 栈

栈是一种基于先进后出策略的集合类型

如图所示，新添加的元素总是放在栈的顶端，取元素的时候，都是取走栈的顶端的元素。

2.2 队列

队列是一种基于先进先出策略的集合类型

三、代码实现

3.1 栈（数组实现）

下面是实现一个泛型的可自动调整数组大小的栈

public class ResizingArrayStack<T> implements Iterable<T> {

    private T[] arr = (T[]) new Object[1];

    //元素数量
    private int n = 0;

    public int size() {
        return n;
    }

    public boolean isEmpty() {
        return n == 0;
    }

    /**
     * 向栈中添加数据
     * @param t
     * @return
     */
    public void push(T t) {
        if (n == arr.length)
            resize(arr.length * 2);
        arr[n++] = t;
    }

    public T pop() {
        T t = arr[--n];
        arr[n] = null;  //避免对象游离（游离：保存一个不需要的对象的引用）
        if (n > 0 && n == arr.length / 4)
            resize(arr.length/2);
        return t;
    }


    /**
     * 动态扩缩容数组
     * @param newSize
     */
    private void resize(int newSize) {
        T[] t = (T[]) new Object[newSize];
        for (int i = 0; i < arr.length; i++) {
            t[i] = arr[i];
        }
        arr = t;
    }

    @Override
    public Iterator<T> iterator() {
        return new ReverseArrayIterator();
    }

    /**
     * 迭代器：就是一个实现了next()和hasNext()方法的类的对象
     */
    private class ReverseArrayIterator implements Iterator<T> {

        private int i = n;

        @Override
        public boolean hasNext() {
            return i > 0;
        }

        @Override
        public T next() {
            return arr[--i];
        }

    }

由于某种历史和技术原因，创建泛型数组在java里面是不允许的，我们需要使用强制类型转换（算法第四版原话）。如下

private T[] arr = (T[]) new Object[1];

成员变量栈中元素数量n，size()，isEmpty()很简单，不再赘述。

push()方法——添加新元素

       首先判断元素数量和数组大小是否相等，如果相等就调用resize方法，先创建一个大小为原来数组两倍的数组，再将元素数组中所有元素复制到新数组中，最后将原数组的引用指向新的数组。回到push()方法，最后将新元素添加到数组末尾并将元素数量变量+1。

pop()——弹出最后一个元素

       首先取到最后一个元素并将元素数量减1。但是被取走的元素引用还在存在数组中，而这个元素已经不会再被访问了，但java的垃圾回收机制没法知道这一点，除非引用被覆盖，这种情况（保存一个不需要的对象的引用）叫游离。为了避免对象游离，只需要将被弹出的数组元素的值赋值为null，这将覆盖无用的引用，在用例使用完以后java垃圾回收器就可以回收这个对象的内存。随后判断元素数量是否等于数组大小的四分之一，如果是就调用resize方法，将数组大小缩容为原来大小的1/2。最后返回元素。

迭代器

       所谓迭代器就是一个实现了hasNext()方法和next()方法的类的对象（算法第四版书中内容），在代码中可以看到，调用ResizingArrayStack类的对象的iterator()方法就可以返回一个迭代器了。由于栈是先进后出的，故此迭代器是一个逆序的迭代器。hasNext()方法和next()分别用于判断是否还有元素和取出下一个元素。

优点：

1.每项操作的用时都与集合大小无关。

2.空间需求总是不超过集合大小乘以一个常数

缺陷：

在调用pop和push方法时会调整数组大小，数组的复制比较消耗内存，这项操作的耗时和栈大小成正比。

       栈的实现就分析到这里，总的来说这份泛型的可迭代的Stack API是所有集合类抽象数据类型实现的模板。它几乎（但还没有）达到了任意集合类数据类型的实现的最佳性能

 

3.2 栈（链表实现）

先看链表结构

定义：链表是一种递归的数据结构，它或者为空（null），或者是指向一个节点的引用，该节点含有一个泛型的元素和一个指向另一个链表的引用。（算法第四版的定义）

        构建一条“A”，“B”，“C”的链表

      添加新元素——向表头插入新节点

从表头插入新节点是最容易实现的，首先将first引用保存在oldFirst中，然后创建新节点对象并让first指向这个对象，分别给这个对象的变量item和next赋值。如下图

 

      删除元素——从表头删除节点

这个操作很简单只需要将first指向first的next即可。

栈的代码实现

public class Stack<T> {

    //第一个节点
    private Node first;

    //元素数量
    private int n;

    //链表节点
    private class Node {
        Node next;
        T t;
    }

    public boolean isEmpty() {
        return n == 0;
    }

    private int size() {
        return n;
    }

    public void push(T t) {
        Node oldFirst = first;
        first = new Node();
        first.next = oldFirst;
        first.t = t;
        n++;
    }

    public T pop() {
        Node node = first;
        T t = node.t;
        first = node.next;
        n--;
        return t;
    }

    public Iterator<T> iterator() {
        return new ListIterator();
    }

    private class ListIterator implements Iterator<T> {
        //当前节点
        private Node current = first;

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

        @Override
        public T next() {
            T t = current.t;
            current = current.next;
            return t;
        }

    }

对比数组实现，这里多了一个Node类型的内部类，push()方法和pop()方法以及迭代器的实现发生了变化，由之前的数组实现换成链表实现。push()和pop()的实现见上面链表结构的分析，迭代器的hasNext方法就是判断当前current是否为空，next()返回当前对象的t元素，在将current指向current的next。

这份基于泛型链表实现的栈，它可以用于创建任意数据类型的栈

2.3 队列（链表实现）

如下面算法代码，将队列表示为一条从最早插入的元素到最近插入的元素的链表。

/**
 * 队列（链表实现）
 *
 * 在结构化存储数据集时，链表是数组的一种重要的替代方式
 * @param <T>
 */
public class Queue<T> implements Iterable<T> {

    //队列的开头
    private Node first;

    //队列的结尾
    private Node last;

    //队列的长度
    private int n;

    private class Node {
        Node next;
        T t;
    }

    public boolean isEmpty() {
        return n == 0;
    }

    public int size() {
        return n;
    }

    /**
     * 向队列添加元素
     * 注意：如果队列为空，则first和last都指向新节点
     * 否则将旧的最后一个元素指向新节点
     * @param t
     */
    public void enqueue(T t) {
        Node oldLast = last;
        last = new Node();
        last.t = t;
        last.next = null;
        if (isEmpty()) {
            first = last;
        } else {
            oldLast.next = last;
        }
        n++;
    }

    /**
     *
     * @return
     */
    private T dequeue() {
        T t = first.t;
        first = first.next;
        n--;
        if (isEmpty()) {
            last = null;
        }
        return t;
    }

    public Iterator<T> iterator() {
        return new LinkIterator();
    }

    private class LinkIterator implements Iterator<T> {

        private Node current = first;

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

        @Override
        public T next() {
            T t = current.t;
            current = current.next;
            return t;
        }

        @Override
        public void remove() {

        }
    }

    public static void main(String[] args) {
        Queue<String> queue = new Queue<>();
        queue.enqueue("rick");
        queue.enqueue("Tom");
        queue.enqueue("Simba");
//        System.out.println(queue.size());
//        System.out.println(queue.dequeue());
//        System.out.println(queue.dequeue());
//        System.out.println(queue.dequeue());
        queue.enqueue("Doris");

        Iterator<String> iterator = queue.iterator();
        System.out.println("队列数据：");
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }

}

       实例变量first指向队列的开头，实例变量last指向队列的结尾。要想一个元素入列，就调用enqueue()方法将元素添加到队列结尾(但是如果链表为空的话，则first和last都指向新节点，否则将旧的最后一个元素指向新节点)；要将一个元素出列，就调用dequeue()方法从表头删除一个节点（但是如果链表为空的话，就要将实例变量last赋值为null）

三、总结

在结构化存储数据集时，链表是数组的一种重要的替代方式

 

仅以此博献给我伟大的java语言，如有不当之处，欢迎大神指正。谢谢！！！