java实现栈MyStack,底层使用数组和链表实现

栈是一种操作受限的线性表，只能在一端插入和删除元素。（FILO）
具体用java实现：

/**
 * 栈的接口，规定了栈的基本操作
 */
public interface MyStack<Item> extends Iterable<Item>{
    /**
     * 初始化栈
     */
    public void initStack(int maxSize);

    /**
     * 判断栈是否为空
     * @return 如果栈为空，返回true
     */
    public boolean isEmpty();

    /**
     * 判断栈是否已经满了
     * @return  如果栈满了返回true
     */
    public boolean isFull();

    /**
     * 将元素压入栈中
     * @param item 将要入栈的元素
     * @return  如果压栈成功返回true
     */
    public boolean push(Item item);

    /**
     * 将元素出栈
     * @return  返回出栈的元素
     */
    public Item pop();

    /**
     * 获取栈顶的元素，但是不出栈
     * @return 栈顶的元素
     */
    public Item getTop();

    /**
     * 销毁栈，让栈变成初始的状态
     */
    public void clearStack();
}

import cn.edu.dhu.MyStack;

import java.util.Iterator;

/**
 * 栈的实现类，实现了栈的接口中的方法
 * 底层采用数组实现，并且有一个索引指针来维护栈顶的位置
 * 初始化的时候，栈顶指针为-1，入栈的时候，先让栈顶指针++，然后入栈
 * 出栈的时候先取栈顶的元素，然后让栈顶指针--，
 * 判断栈为空的条件：栈顶指针==-1
 * 判断栈满的条件:栈顶指针==maxsize-1
 *
 * @param <Item>
 */
public class MyArrayStackImpl<Item> implements MyStack<Item> {
    private Item[] items;
    private int top;
    private int maxSize;

    /**
     * 无参构造器，默认大小为10
     */
    public MyArrayStackImpl() {
        initStack(10);
    }

    /**
     * 有参数构造器
     * @param maxSize 栈的容量
     */
    public MyArrayStackImpl(int maxSize) {
        initStack(maxSize);
    }

    @Override
    public void initStack(int maxSize) {
        items= (Item[]) new Object[maxSize];
        top=-1;
        this.maxSize=maxSize;
    }

    @Override
    public boolean isEmpty() {
        return top==-1;
    }

    @Override
    public boolean isFull() {
        return top==maxSize-1;
    }

    @Override
    public boolean push(Item item) {
        if(isFull()){
            return false;
        }
        top++;
        items[top]=item;
        return true;
    }

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

    @Override
    public Item getTop() {
        if (isEmpty()){
            return null;
        }
        return items[top];
    }

    @Override
    public void clearStack() {
        initStack(10);
    }

    @Override
    public Iterator<Item> iterator() {
        return new MyStackIterator();
    }

    private class MyStackIterator implements Iterator<Item>{
        private int cur=top;
        @Override
        public boolean hasNext() {
            return cur!=-1;
        }

        @Override
        public Item next() {
            Item item=items[cur];
            cur--;
            return item;
        }
    }
}

import cn.edu.dhu.MyStack;

import java.util.Iterator;

/**
 * 栈的实现，底层使用链表
 * @param <Item>
 */
public class MyLinkedStackImpl<Item> implements MyStack<Item> {
    /**
     * 内部类，一个结点
     */
    private class Node{
        Item item;
        Node next;
    }

    private Node first;
    private int N;

    /**
     * 链式不带头结点的链表不用初始化
     * @param maxSize
     */
    @Override
    public void initStack(int maxSize) {
        return;
    }

    @Override
    public boolean isEmpty() {
        return first==null;
    }

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

    @Override
    public boolean push(Item item) {
        if(first==null){
            Node firstNode =new Node();
            firstNode.item=item;
            firstNode.next=null;
            first=firstNode;
            N++;
            return true;
        }
        Node newNode =new Node();
        newNode.item=item;
        newNode.next=first;
        first=newNode;
        N++;
        return true;
    }

    @Override
    public Item pop() {
        if(N==0){
            return null;
        }
        else if(N==1){
            Item item=first.item;
            first=null;
            N--;
            return item;
        }
        else{
            Item item=first.item;
            first=first.next;
            N--;
            return item;
        }
    }

    @Override
    public Item getTop() {
        if(first==null){
            return null;
        }
        return first.item;
    }

    @Override
    public void clearStack() {
        first=null;
        N=0;
    }

    @Override
    public Iterator<Item> iterator() {
        return new MyLinkedStackIterator();
    }

    private class MyLinkedStackIterator implements Iterator<Item>{
        private Node p=first;
        @Override
        public boolean hasNext() {
            return p!=null;
        }

        @Override
        public Item next() {
            Item item=p.item;
            p=p.next;
            return item;
        }
    }
}

import cn.edu.dhu.MyStack;

import java.util.Iterator;

public class MyLinkedStackWithHeadNodeImpl<Item> implements MyStack<Item> {
    private Node first;
    private int N;
    private class Node{
        Item item;
        Node next;
    }

    public MyLinkedStackWithHeadNodeImpl() {
        initStack(10);
    }

    @Override
    public void initStack(int maxSize) {
        Node node=new Node();
        node.item=null;
        node.next=null;
        first=node;
    }

    @Override
    public boolean isEmpty() {
        return first.next==null;
    }

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

    @Override
    public boolean push(Item item) {
        Node newNode =new Node();
        newNode.item=item;
        newNode.next=first.next;
        first.next=newNode;
        N++;
        return true;
    }

    @Override
    public Item pop() {
        if (isEmpty()){
            return null;
        }
        Item item=first.next.item;
        first.next=first.next.next;
        N--;
        return item;
    }

    @Override
    public Item getTop() {
        if (isEmpty()){
            return null;
        }
        return first.next.item;
    }

    @Override
    public void clearStack() {
        initStack(10);
    }

    @Override
    public Iterator<Item> iterator() {
        return new MyStackIterator();
    }

    private class MyStackIterator implements Iterator<Item>{
        private Node cur =first.next;
        @Override
        public boolean hasNext() {
            return cur!=null;
        }

        @Override
        public Item next() {
            Item item=cur.item;
            cur=cur.next;
            return item;
        }
    }
}