数据结构与算法-栈

　　先进后出的一种数据结构。

　　特殊的数组或者链表，线性表。

　　存在限制条件，只能操作栈顶。

 

一：有趣的题目

1.设计一个括号匹配的功能

package com.jun.algorithm.foundation.main;

import java.util.Objects;

/**
 * 括号问题
 * <p>
 * 右括号来了，就找栈顶看是否可以匹配，匹配就出栈
 * 最后栈应该是空
 *
 * @author caojun
 */
public class Bracket {
    public static boolean isOk(String str) {
        StackImpl<Character> brackets = new StackImpl<>(20);
        char[] chars = str.toCharArray();

        for (Character c : chars) {
            switch (c) {
                case '{':
                case '(':
                case '[':
                    brackets.push(c);
                    break;
                case '}':
                    if (Objects.equals('{', brackets.pop())) {
                        break;
                    } else {
                        return false;
                    }
                case ']':
                    if (Objects.equals('[', brackets.pop())) {
                        break;
                    } else {
                        return false;
                    }
                case ')':
                    if (Objects.equals('(', brackets.pop())) {
                        break;
                    } else {
                        return false;
                    }
            }
        }
        return brackets.isEmpty();
    }
}

　　

　

 

二：栈

1.具体的实现

package com.jun.algorithm.foundation.main;

/**
 * 栈的接口
 *
 * @param <Item>
 * @author caojun
 */
public interface IStack<Item> {

    void push(Item item);

    Item pop();

    int size();

    boolean isEmpty();
}

　　

　　具体是数组方式实现：

package com.jun.algorithm.foundation.main;

/**
 * 栈的实现
 * 通过数组实现
 *
 * @author caojun
 */
public class StackImpl<Item> implements IStack<Item> {

    private Item[] a = (Item[]) new Object[1];
    private int n = 0;

    public StackImpl() {

    }

    public StackImpl(int cap) {
        a = (Item[]) new Object[cap];
    }

    @Override
    public void push(Item item) {
        judgeSize();
        a[n++] = item;
    }

    @Override
    public Item pop() {
        if (isEmpty()) {
            return null;
        }
        Item item = a[--n];
        a[n] = null;
        return item;
    }

    @Override
    public int size() {
        return 0;
    }

    @Override
    public boolean isEmpty() {
        return false;
    }

    private void judgeSize() {
        // 扩展
        if (a.length < n) {
            reSize(2 * a.length);
        }
        if (n > 0 && n < a.length / 2) {
            reSize(a.length / 2);
        }
    }

    private void reSize(int size) {
        Item[] temp = (Item[]) new Object[size];
        for (int i = 0; i < n; i++) {
            temp[i] = a[i];
        }
        a = temp;
    }
}