栈

1、介绍

栈是一种线性存储结构，栈中的数据是按照“后进先出”（LIFO）的规则进出栈的。栈有三种操作，peek，获取栈顶元素，pop将栈顶的值弹出，push，存入新值到栈顶。在添加和删除元素时只能在栈顶进行操作。

2、用数组实现（能存任何类型的数据）

①、接口

interface Stack<T>{
    public T pop();
    public boolean push(T data);
    public T peek();
    public void printStack();
    public boolean isFull();
    public boolean isNull();
}

②、实现类

class ArrayStack<T> implements Stack<T>{
    private static final int DEFAULT_LENGTH = 15;
    private int top;
    private int length;
    private T[] stackArrayT;
    public ArrayStack(Class<T> typeClass){
        this(typeClass,DEFAULT_LENGTH);
    }
    @SuppressWarnings("unchecked")
    public ArrayStack(Class<T> typeClass,int length){
        this.length = length;
        this.top = -1;
        //根据类型和长度直接通过反射直接创建数组
        stackArrayT = (T[]) Array.newInstance(typeClass, length);
    }
    @Override
    public T pop() {
        // TODO Auto-generated method stub
        if (isNull())
            throw new NoSuchElementException();
        T data = stackArrayT[top--];
        return data;
    }

    @Override
    public boolean push(T data) {
        // TODO Auto-generated method stub
        if(isFull())
            return false;
        stackArrayT[++top] = data;
        return true;
    }

    @Override
    public boolean isFull() {
        // TODO Auto-generated method stub
        return length == top+1;
    }

    @Override
    public boolean isNull() {
        // TODO Auto-generated method stub
        return top == -1;
    }
    @Override
    public T peek() {
        // TODO Auto-generated method stub
        if (isNull())
            throw new NoSuchElementException();
        return stackArrayT[top];
    }
    @Override
    public void printStack() {
        // TODO Auto-generated method stub
        if(!isNull()){
            int i = top;
            while(i>-1){
                System.out.print(stackArrayT[i--]);
            }
        }
        System.out.println();
    }
    public int length(){
        return length;
    }
}

3、用单链表实现

实现类：

class LinkedStack<T> implements Stack<T>{
    private Node<T> firstNode;
    private int size = 0;
    private static class Node<T>{
        T item;
        Node<T> next;
        Node(T item,Node<T> nextNode){
            this.item = item;
            this.next = nextNode;
        }
    }
    public void addFirst(T item){
        Node<T> newNode = new Node<>(item, firstNode);
        firstNode = newNode;
        size++;
    }   
    public T removeFirst(){
        if (isNull())
            throw new NoSuchElementException();
        T item = firstNode.item;
        firstNode = firstNode.next;
        size--;
        return item;
    }
    @Override
    public T pop() {
        // TODO Auto-generated method stub  
        return removeFirst();
    }

    @Override
    public boolean push(T data) {
        // TODO Auto-generated method stub
        addFirst(data);
        return true;
    }

    @Override
    public T peek() {
        // TODO Auto-generated method stub
        if (isNull())
            throw new NoSuchElementException();
        return firstNode.item;
    }

    @Override
    public void printStack() {
        // TODO Auto-generated method stub
        while(firstNode != null){
            System.out.print(peek());
            firstNode = firstNode.next;
        }
        System.out.println();
    }

    @Override
    public boolean isFull() {
        // TODO Auto-generated method stub
        return false;
    }

    @Override
    public boolean isNull() {
        // TODO Auto-generated method stub
        return size == 0;
    }
    public int size(){
        return size;
    }
}

这里面有个内部类定义了节点类型：

    private static class Node<T>{
        T item;
        Node<T> next;
        Node(T item,Node<T> nextNode){
            this.item = item;
            this.next = nextNode;
        }
    }

4、通过接口进行操作

①、添加测试

    public static void pushTest(Stack<Integer> stack){
            stack.push(1);
            stack.push(2);
            stack.push(3);
            stack.printStack();
        }

main调用：

ArrayStack<Integer> arrayStack = new ArrayStack<>(Integer.class);
        LinkedStack<Integer> linkedStack = new LinkedStack<>();
        pushTest(arrayStack);
        pushTest(linkedStack);

②、字序反转

    public static void reverse(Stack<Character> stack,String in){
        int length = in.length();
        for (int i = 0; i < length; i++) {
            if(!stack.isFull()){
                stack.push(in.charAt(i));
            }else break;
        }
        stack.printStack();
    }

main中调用：

    ArrayStack<Character> arrayStack2 = new ArrayStack<>(Character.class);
    LinkedStack<Character> linkedStack2 = new LinkedStack<>();
    String in = "12345678";
    reverse(arrayStack2, in);
    reverse(linkedStack2, in);

③、检查分隔符顺序是否正确

    public static void check(Stack<Character> stack,String in){
        for (int i = 0; i < in.length(); i++) {
            if(!stack.isFull()){
                switch (in.charAt(i)) {
                case '{':
                case '[':
                case '(':stack.push(in.charAt(i));break;

                case '}':
                case ']':
                case ')':if(stack.peek().equals(in.charAt(i)))
                            stack.pop();break;  
                }
            }else 
                break;
        }
        if(stack.isNull())
            System.out.println("符合");
        else 
            System.out.println("不符合");
    }

main中调用：

        ArrayStack<Character> arrayStack2 = new ArrayStack<>(Character.class);
        LinkedStack<Character> linkedStack2 = new LinkedStack<>();
        String in = "a{b[c(d)e]f}";
        String in2 = "c{a[v(]a)v}";
        check(arrayStack2, in2);
        check(linkedStack2, in2);

当采用in的时候输出符合，当采用in2的时候输出不符合，程序正确。