栈代码

package StackDemo;

public interface Stack<E> {
    boolean isEmpty();

    void push(E data);

    E pop();

    E peek();

    void clear();

    int length();
}

1.栈的顺序存储

package StackDemo.SequenceStackTest;

import StackDemo.Stack;

import java.util.Arrays;

//使用数组实现栈
public class SequenceStack<E> implements Stack<E> {
    //默认长度
    private static int DEFAULT_SIZE = 10;
    //当前栈内元素个数
    private int size = 0;
    //数组的长度
    private int capacity;
    //保存栈内元素的数组
    private Object[] elementData;
    //初始化数组
    public SequenceStack(){
        this.capacity=DEFAULT_SIZE;
        elementData=new Object[capacity];
    }
    //指定长度初始化数组
    public SequenceStack(int initSize) {
        this.capacity = initSize;
        elementData = new Object[capacity];
    }

    @Override
    public boolean isEmpty() {
        return size==0;
    }
    //入栈
    @Override
    public void push(E data) {
        checkIsFull();
        elementData[size++]=data;//一开始size=0
    }
    //出栈
    @Override
    public E pop() {
        checkIsEmpty();
        E e=(E) elementData[size-1];
        elementData[--size]=null;
        return e;
    }
    //取栈顶元素
    @Override
    public E peek() {
        checkIsEmpty();
        E e=(E) elementData[size-1];
        return e;
    }
    //清空栈
    @Override
    public void clear() {
        Arrays.fill(elementData,null);
        size=0;
    }

    @Override
    public int length() {
        return size;
    }
    //栈满抛出异常
    private void checkIsFull(){
        if(size==capacity-1){
            throw new IndexOutOfBoundsException("栈满");
        }
    }
    //若栈空则抛出异常
    private void checkIsEmpty() {
        if (isEmpty()) {
            throw new IndexOutOfBoundsException("栈是空的");
        }
    }

    @Override
    public String toString() {
        if(size==0){
            return "[]";
        }else{
            StringBuilder sb=new StringBuilder("[");
            for(int i=size-1;i>0;i--){
                sb.append(elementData[i].toString()+",");
            }
            sb.append(elementData[0].toString());
            return sb.append("]").toString();
        }
    }
}

package StackDemo.SequenceStackTest;

public class SequenceStacktest {
    public static void main(String[] args) {
        SequenceStack<Integer> stack=new SequenceStack<>();
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);
        stack.push(5);
        stack.push(6);
        System.out.println("打印栈：");
        System.out.println(stack);
        System.out.println("判断是否为空");
        System.out.println(stack.isEmpty());
        System.out.println("取出栈顶元素：");
        System.out.println(stack.peek());
        System.out.println("出栈:");
        System.out.println(stack.pop());
        System.out.println(stack);
        System.out.println("清空栈：");
        stack.clear();
        System.out.println(stack);

    }
}

2. 栈的链式存储

package StackDemo.LinkStackTest;

import StackDemo.Stack;
//使用链表实现栈
public class LinkStack<E> implements Stack<E> {

    private static class Node<E>{
        E item;
        Node<E> next;
        public Node(){
        }
        public Node(E item,Node<E>next){
            this.item=item;
            this.next=next;
        }
    }
    //当前栈内元素个数
    private int size;
    //栈顶
    private Node<E> top;
    //初始化栈
    public LinkStack() {
        top = null;
        size = 0;
    }
    //以默认元素来构建栈
    public LinkStack(E data) {
        this();
        Node<E> newNode = new Node<>(data, null);
        newNode.next = top;
        top = newNode;
        size++;
    }
    @Override
    public boolean isEmpty() {
        return size==0;
    }

    @Override
    public void push(E data) {
        Node<E> node=new Node<>(data,null);
        node.next=top;
        top=node;
        size++;
    }

    @Override
    public E pop() {
        checkIsEmpty();
        Node<E> node=top;//将栈顶元素赋值给一个新的结点
        top=top.next;//移动top指针
        node.next=null;//删除栈顶元素
        size--;
        return node.item;
    }

    @Override
    public E peek() {
        checkIsEmpty();
        return top.item;
    }

    @Override
    public void clear() {
        for (Node<E> node = top; node != null; ) {
            Node<E> next = node.next;
            node.item = null;
            node = next;
        }
        size = 0;
    }

    @Override
    public int length() {
        return size;
    }
    private void checkIsEmpty() {
        if (isEmpty()) {
            throw new IndexOutOfBoundsException("当前栈为空");
        }
    }

    @Override
    public String toString() {
        if(isEmpty()){
            return "[]";
        }else{
            StringBuilder sb=new StringBuilder("[");
            Node<E> node=new Node<>();
            for(node=top;node.next!=null;node=node.next){
                sb.append(node.item.toString()+",");
            }
            sb.append(node.item.toString()+"]");
            return sb.toString();
        }
    }
}

package StackDemo.LinkStackTest;

public class LinkStacktest {
    public static void main(String[] args) {
        LinkStack<String>stack=new LinkStack<>();
        stack.push("a");
        stack.push("b");
        stack.push("c");
        stack.push("d");
        stack.push("e");
        stack.push("f");
        System.out.println("打印当前栈"+stack);
        System.out.println("取出栈顶"+stack.pop());
        System.out.println("输出栈顶"+stack.peek());
        System.out.println("输出长度"+stack.length());
        stack.clear();
        System.out.println(stack);
    }
}