Android 从零学数据结构与算法（2）——栈和队列（Stack、Vector源码分析、逆波兰表达式、队列）

最新推荐文章于 2024-08-04 17:57:28 发布

ZhangJiaNan_Marks

最新推荐文章于 2024-08-04 17:57:28 发布

阅读量709

点赞数

CC 4.0 BY-SA版权

分类专栏：数据结构与算法文章标签：数据结构与算法栈 Vector 逆波兰表达式队列

本文链接：https://blog.youkuaiyun.com/ZhangJiaNan_Marks/article/details/80310927

数据结构与算法专栏收录该内容

6 篇文章

订阅专栏

本博客的原创文章，都是本人平时学习所做的笔记，不做商业用途，如有侵犯您的知识产权和版权问题，请通知本人，本人会即时做出处理删除文章。

栈：栈是限定仅在表尾进行插入和删除操作的线性表。

队列：队列是只允许在一端进行插入操作、而在另一端进行删除操作的线性表。

允许插入和删除的一端为栈顶（Top），另一端称为栈底（bottom），不含任何数据元素的栈称为空栈。栈又称为后进先出的线性表。

Stack和Vector

Stack继承Vector，Stack也是用数组来实现的。 Stack整个类的方法就5个，push(E item)入栈，pop()出栈，peek()获取栈顶元素，enpty()判断是否为空栈，search(Object o)查询栈内元素位置。每个方法声明上都有synchronized修饰。因此Stack是线程安全的。而大部分的业务逻辑是调用父类Vector的方法实现的。

    public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    //数据存储
    protected Object[] elementData;
    //元素数量
    protected int elementCount;
    //扩容增长因子
    protected int capacityIncrement;
    public Vector(int initialCapacity, int capacityIncrement) {
      
}

通过源码我们可以看到Vector是由Object[]实现的，扩容因子变量capacityIncrement和数组长度initialCapacity是可以通过构造方法设置的，如果不设置initialCapacity默认是10，capacityIncrement默认是0。

   public synchronized E peek() {
        ...
        return elementAt(len - 1);
    }

    public synchronized E elementAt(int index) {
          ...
        return elementData(index);
    }

  E elementData(int index) {
        return (E) elementData[index];
    }

peek()方法只是获取栈顶的元素，并不会删除元素，数组的下标0为栈底，数组的下表length-1为栈顶。源码很简单很清晰。

    public synchronized E pop() {
         ...
        obj = peek();
        removeElementAt(len - 1);
        return obj;
    }

    public synchronized void removeElementAt(int index) {
          ...
        elementCount--;
        elementData[elementCount] = null; /* to let gc do its work */
    }

pop()出栈是先调用peek()获取栈顶元素，然后elementCount元素数量减1，elementData栈顶元素设置为空。

出栈后，elementData数组的大小没有改变，也就是说没有缩小容量。只是把元素的数量减1了。

  public E push(E item) {
        addElement(item);
        return item;
    }

    public synchronized void addElement(E obj) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = obj;
    }

  private void ensureCapacityHelper(int minCapacity) {
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

   private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

push(E item)入栈直接调用父类Vector的addElement(E obj)方法，然后调用ensureCapacityHelper(int minCapacity)方法判断是否要扩容。注意：elementData.length是数组的长度，elementCount是元素的个数，如果elementCount+1>elementData.length我们需要调用grow(int minCapacity)方法扩容了。如果扩容因子capacityIncrement大于0,就扩容capacityIncrement大小。如果小于0就扩容一倍。如果扩容之后大小还是不够，就用元素数量的大小来扩容。而hugeCapacity（int minCapacity）方法一般是调用不到的，我们不会用到0x7fffffff-8这么大的容量。然后我们回到addElement(E obj)方法，扩容结束后，把obj放入栈顶，整个入栈就结束了。search(Object o)的业务逻辑也很简单，从栈顶往栈底遍历元素，一个一个比较。返回第一个相等元素的坐标。我就不贴源码了。

逆波兰表达式

栈最经典的应用就是逆波兰表达式，逆波兰表达式也叫后缀表达式。例如：783+3*+102/+；而8+（2-1）*10，这是中缀表达式。中缀表达式是我们计算用的，而后缀表达式是计算机采用的。具体运算方式：

中缀表达式运算：7+（8+1）*3+10/2=39；

后缀表达式运算：7 8 1+3*+10 2/+

7 9 3*+10 2/+ 8 1+运算结果为9

7 27+10 2/+ 9 3*运算结果27

34 10 2 /+ 7 27+运算结果34

34 5+ 10 2 /运算结果5

39 34 5+ 运算结果39

后缀运算是碰到符号，把符号前两个数运算。中缀表达式转后缀表达式就是利用的栈结构。让我们来看看是怎么转的。

上图就是中缀表达式转后缀表达式，看着是不是有点迷糊，很难找到规律。其实是有规律的，记住这个口诀：数字输出，运算符进栈，括号匹配出栈，栈顶优先级低出栈。大概意思就是遇到数字就打印，遇到运算符运算符进栈，当匹配到闭合括号时括号内的运算符就出栈，如果栈顶的优先级比下面的低，优先级高的出栈，运算符低的入栈。同级的运算符栈底比栈顶高。最后数字都输出完了栈内符号按优先级全部输出。下面看看计算机是怎么运算的：