【数据结构】自己实现一个栈

接口：

package fwb.stack;

/**
 * @program: Stack
 * @description: 栈
 * @author: fwb
 * @create: 2019-05-26 14:10
 **/
public interface Stack<T> {
    /** 
    * @Description: 入栈
    * @Param: [t] 
    * @return: boolean 
    */ 
    boolean push(T t);
    /**
    * @Description: 出栈
    * @Param: []
    * @return: T
    */
    T pop();
    /**
    * @Description: 返回栈顶元素但是不出栈
    * @Param: []
    * @return: T
    */
    T peek();
    /**
    * @Description: 返回当前栈的个数
    * @Param: []
    * @return: int
    */
    int getSzie();
    /**
    * @Description: 栈是否为空
    * @Param: []
    * @return: boolean
    */
    boolean isEmpty();
}

顺序表实现栈（优先考虑）

package fwb.stack.Impl;

import fwb.stack.Stack;

import java.util.Arrays;

/**
 * @program: Stack
 * @description: （顺序栈）基于数组的实现
 * @author: fwb
 * @create: 2019-05-26 14:23
 **/
public class ArrayStack<T> implements Stack<T>{
    //存放数据
    private Object[] elementData;
    //最多存放的元素个数
    private int maxSize;
    //当前存放个数
    private int currentSize;

    public ArrayStack(int maxSize) {
        this.elementData = new Object[maxSize];
        this.maxSize = maxSize;
    }
    //入栈
    @Override
    public boolean push(T t) {
        //首先判断一下栈是否满了
        if (currentSize == maxSize){
            int oldSize = maxSize;
            int newSize = oldSize<<1;//乘2
            maxSize = newSize;
            elementData = Arrays.copyOf(elementData,maxSize);
        }
//        if (currentSize == maxSize){
//            int oldSize = maxSize;
//            int newSize = oldSize<<1;//乘2
//            if (newSize + 8 >= Integer.MAX_VALUE){
//                System.out.println("栈太大");
//                return false;
//            }else{
//                maxSize = newSize;
//            }
//            elementData = Arrays.copyOf(elementData,maxSize);
//        }
        elementData[currentSize++] = t;
        return true;
    }
    //出栈
    @Override
    public T pop() {
        if (isEmpty()){
            System.out.println("栈为空");
            return null;
        }
        return (T) elementData[--currentSize];
    }
    //返回栈顶元素但是不出栈
    @Override
    public T peek() {
        if (isEmpty()){
            System.out.println("栈为空");
            return null;
        }
        return (T) elementData[currentSize - 1];//只是返回并不用出栈
    }

    @Override
    public int getSzie() {
        return currentSize;
    }

    @Override
    public boolean isEmpty() {
        return currentSize == 0;
    }
}

链表实现栈

package fwb.stack.Impl;

import fwb.stack.Stack;

/**
 * @program: stack
 * @description: 链式栈
 * @author: fwb
 * @create: 2019-05-26 15:44
 **/
public class LinkedStack<T> implements Stack<T> {
    private Node top;//栈顶元素
    private int currentSize;//数量
    private class Node{
        private T t;
        private Node next;

        public Node(T t, Node next) {
            this.t = t;
            this.next = next;
        }
    }

    @Override
    public boolean push(T t) {
        Node newNode = new Node(t,null);
        if (top == null){
            top = newNode;
        }else{
            newNode.next = top;
            top = newNode;
        }
        currentSize++;
        return true;
    }

    @Override
    public T pop() {
        if (isEmpty()){
            System.out.println("当前栈为空");
            return null;
        }
        T result = top.t;//先取得当前栈顶的元素的值
        top = top.next;
        currentSize--;
        return result;
    }

    @Override
    public T peek() {
        if (isEmpty()){
            System.out.println("当前栈为空");
            return null;
        }
        return top.t;
    }

    @Override
    public int getSzie() {
        return currentSize;
    }

    @Override
    public boolean isEmpty() {
        return currentSize == 0;
    }
}