（JAVA）数据结构（二）栈

1. 动态数组

这里用动态数组实现栈的基本操作

package MyStack;

public class Array<E> {
    private E[] data;
    private int size; //数组当前存放元素个数,注意当前的最大索引等于size-1

    /**
     * 构造函数
     *
     * @param：capacity传入数组的容量
     */
    public Array(int capacity) {
        data = (E[]) new Object[capacity];
        size = 0;
    }

    /**
     * 无参构造，默认容量是10
     */
    public Array() {
        this(10); //访问本类的构造方法
    }

    /**
     * 获取当前数组中元素的个数
     */
    public int getSize() {
        return size;
    }

    /**
     * 获取数组的容量
     */
    public int getCapacity() {
        return data.length;
    }

    /**
     * 判断数组是否为空
     */
    public boolean isEmpty() {
        return size == 0;  //如果当前存放元素个数为0，就是空
    }

    /**
     * 向第index个位置插入元素
     *
     * @param index
     * @param e
     */
    public void add(int index, E e) {

        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed.Require index >= 0 and index <= size");
        }
        //判断数组受否已满,如果所装的元素个数等于数组的长度，证明已满
        if (size == data.length) {
            resize(2 * data.length);
        }

        for (int i = size - 1; i >= index; i--) {
            data[i + 1] = data[i];
        }
        data[index] = e;
        size++;
    }


    /**
     * 向数组末尾添加元素
     *
     * @param e
     */
    public void addLast(E e) {
        add(size, e);
    }

    /**
     * 向数组开始位置添加元素
     *
     * @param e
     */
    public void addFirst(E e) {
        add(0, e);
    }


    /**
     * 取出指定索引的元素
     *
     * @param index
     * @return
     */
    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("Get failed.Index is illegal");
        }
        return data[index];
    }

    public E getLast(){
        return get(size-1);
    }
    public  E getFirst(){
        return get(0);
    }

    /**
     * 判断数组中是否包含指定元素
     *
     * @param e
     * @return
     */
    public boolean contains(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)) { //这里做了修改
                return true;
            }
        }
        return false;
    }

    /**
     * 查找值为e的索引值
     *
     * @param e
     * @return
     */
    public int find(E e) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)) {  //这里做了修改
                return i;
            }
        }
        return -1;
    }

    /**
     * 删除指定位置的值
     * @param index
     * @return
     */
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("Delete failed. Index illegal");
        }

        E res = data[index];
        if(index < size -1) { //如果不是最后一个元素
            for (int i = index; i < size; i++) {
                data[i] = data[i + 1];
            }
        }
        size--;
        data[size] = null; //垃圾回收，loitering objects
        //如果删除后元素数量太少，调整数组大小
        if (size == data.length / 4 && data.length/2 != 0) {
            resize(data.length / 2);
        }

        return res;
    }

    /**
     * 删除第一个元素
     *
     * @return
     */
    public E removeFirst() {
        return remove(0);
    }

    /**
     * 删除最后一个元素
     *
     * @return
     */
    public E removeLast() {
        return remove(size - 1);
    }

    /**
     * 删除第一个e
     *
     * @param e
     * @return
     */
    public boolean removeElement(E e) {
        int index = find(e);
        if (index != -1) {
            remove(index);
            return true;
        }
        return false;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append(String.format("Array:size = %d, capacity = %d \n", size, data.length));
        sb.append("[");
        for (int i = 0; i < size; i++) {
            sb.append(data[i]);
            if (i != size - 1) {
                sb.append(", ");
            }
        }
        sb.append("]");
        return sb.toString();
    }
    /**
     * 扩容
     *
     * @param newcapacity
     */
    private void resize(int newcapacity) {
        E[] newData = (E[]) new Object[newcapacity];
        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }

}

2. 实现栈的功能

首先，定义一个Stack接口

public interface Stack<E> {
    void push(E e);
    E pop();
    E peak();
    int getSize();
    boolean isEmpty();
}

实现栈的功能

import MyStack.Array;

public class ArrayStack<E> implements Stack<E> {
    Array<E> array;
    public  ArrayStack(int capacity){
        array = new Array<E>(capacity);
    }
    public ArrayStack(){
        array = new Array<E>();
    }

    @Override
    public void push(E e) {
        array.addLast(e);
    }

    @Override
    public E pop() {
        return array.removeLast();
    }

    @Override
    public E peak() {
        return array.getLast();
    }

    @Override
    public int getSize() {
        return array.getSize();
    }

    @Override
    public boolean isEmpty() {
        return array.isEmpty();
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("Stack:");
        sb.append("[");
        for(int i=0 ; i<array.getSize() ;i++){
            sb.append(array.get(i));
            if (i != array.getSize()-1) {
                sb.append(", ");
            }
        }
        sb.append("] top");
        return sb.toString();
    }
}

3. 实例演示

输入一个带有括号的字符串，判断括号是否匹配，例如"{([])}"，"()[]{}","{}[()]“这些类似的都是匹配的，而”{(})[]"这种就是不匹配的。用栈就可以很好的解决这个问题：

package Solution;

import java.util.Stack;

public class Solution {
    public static void main(String[] args) {
        Solution s = new Solution();
        boolean flag = s.isValid("{()}[]");
        System.out.println(flag);
    }
    public boolean isValid(String s) {
        Stack<Character> stack = new Stack<>();

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);

            if (c == '(' || c == '[' || c == '{') {
                stack.push(c);
            } else {
                if (stack.isEmpty()) {
                    return false;
                }
                char topChar = stack.pop();
                if (topChar == '(' && c != ')')
                    return false;
                if (topChar == '[' && c != ']')
                    return false;
                if (topChar == '{' && c!='}')
                    return false;
            }

        }
        return stack.isEmpty();
    }

}