Java栈的实现

栈定义

栈(stack)是限定仅在表尾进行插入或删除操作的线性表。
对栈来说，表尾端有其特殊含义，称为栈顶(top)，相应地表头端称为栈底(bottom)。不含元素的空表称为空栈。

栈的修改是按后进先出的原则进行的，因此，栈又称为后进先出（Last in first out）的线性表（简称LIFO结构）。

栈的属性与方法

Java程序代码实现

public interface IMyStack<T> {

    /*
     * 入栈
     */
    boolean push(T data);

    /*
     * 出栈
     */
    T pop();

    /*
     * 栈的长度
     */
    int length();

    /*
     * 栈是否为空
     */
    boolean isEmpty();

    /*
     * 清空栈
     */
    void clear();
}

栈的顺序表示

定义：

顺序栈：即栈的顺序存储结构是利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素，同时附设指针（top）指示栈顶元素在顺序栈中的位置。

代码：

java程序代码实现

public class MyArrayStack<T> implements IMyStack<T> {

    private Object[] objs = new Object[16];
    private int size;

    @Override
    public boolean push(T data) {
        if(size >= objs.length){
            addLength();
        }
        objs[size++]=data;
        return true;
    }

    @SuppressWarnings("unchecked")
    @Override
    public T pop() {
        if(size==0){
            return null;
        }
        return (T) objs[--size];
    }

    @Override
    public int length() {
        return size;
    }

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

    @Override
    public void clear() {
        for (int i = 0; i < size; i++) {
            objs[i] = null;
        }
        size = 0;
    }

    @Override
    public String toString(){
        StringBuffer sb = new StringBuffer();
        sb.append("MyArrayStack:[");
        for (int i = 0; i < size; i++) {
            sb.append(objs[i]);
            if(i != size-1){
                sb.append(",");
            }
        }
        sb.append("]");
        return sb.toString();
    }

    /*
     * 扩容数组
     */
    private void addLength() {
        Object[] temp = new Object[size*3/2+1];
        for(int i=0; i<size; i++){
            temp[i] = objs[i];
            objs[i] = null;
        }
        objs = temp;
    }
}

栈的链式表示

定义：

链栈用链表作为存储结构，栈初始化时仅需给栈顶指针分配内存空间，而后每当有数据入栈时再为该数据分配空间，这样实现了内存空间的动态分配。

代码：

java程序代码实现

public class MyLinkedStack<T> implements IMyStack<T> {

    /*
     * 栈顶指针
     */
    private Node<T> top;
    /*
     * 栈的大小
     */
    private int size;

    public MyLinkedStack() {
        this.top = null;
        this.size = 0;
    }

    @Override
    public boolean push(T data) {
        Node<T> node = new Node<T>(data);
        node.next = top;
        // 修改栈顶指针
        top = node;
        size++;
        return true;
    }

    @Override
    public T pop() {
        if(top == null){
            return null;
        }
        Node<T> node = top;
        // 修改栈顶指针
        top=node.next;
        size--;
        return node.data;
    }

    @Override
    public int length() {
        return size;
    }

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

    @Override
    public void clear() {
        top = null;
        size = 0;
    }

}

栈定义

栈(stack)是限定仅在表尾进行插入或删除操作的线性表。
对栈来说，表尾端有其特殊含义，称为栈顶(top)，相应地表头端称为栈底(bottom)。不含元素的空表称为空栈。

栈的修改是按后进先出的原则进行的，因此，栈又称为后进先出（Last in first out）的线性表（简称LIFO结构）。

栈的属性与方法

Java程序代码实现

public interface IMyStack<T> {

    /*
     * 入栈
     */
    boolean push(T data);

    /*
     * 出栈
     */
    T pop();

    /*
     * 栈的长度
     */
    int length();

    /*
     * 栈是否为空
     */
    boolean isEmpty();

    /*
     * 清空栈
     */
    void clear();
}

栈的顺序表示

定义：

顺序栈：即栈的顺序存储结构是利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素，同时附设指针（top）指示栈顶元素在顺序栈中的位置。

代码：

java程序代码实现

public class MyArrayStack<T> implements IMyStack<T> {

    private Object[] objs = new Object[16];
    private int size;

    @Override
    public boolean push(T data) {
        if(size >= objs.length){
            addLength();
        }
        objs[size++]=data;
        return true;
    }

    @SuppressWarnings("unchecked")
    @Override
    public T pop() {
        if(size==0){
            return null;
        }
        return (T) objs[--size];
    }

    @Override
    public int length() {
        return size;
    }

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

    @Override
    public void clear() {
        for (int i = 0; i < size; i++) {
            objs[i] = null;
        }
        size = 0;
    }

    @Override
    public String toString(){
        StringBuffer sb = new StringBuffer();
        sb.append("MyArrayStack:[");
        for (int i = 0; i < size; i++) {
            sb.append(objs[i]);
            if(i != size-1){
                sb.append(",");
            }
        }
        sb.append("]");
        return sb.toString();
    }

    /*
     * 扩容数组
     */
    private void addLength() {
        Object[] temp = new Object[size*3/2+1];
        for(int i=0; i<size; i++){
            temp[i] = objs[i];
            objs[i] = null;
        }
        objs = temp;
    }
}

栈的链式表示

定义：

链栈用链表作为存储结构，栈初始化时仅需给栈顶指针分配内存空间，而后每当有数据入栈时再为该数据分配空间，这样实现了内存空间的动态分配。

代码：

java程序代码实现

public class MyLinkedStack<T> implements IMyStack<T> {

    /*
     * 栈顶指针
     */
    private Node<T> top;
    /*
     * 栈的大小
     */
    private int size;

    public MyLinkedStack() {
        this.top = null;
        this.size = 0;
    }

    @Override
    public boolean push(T data) {
        Node<T> node = new Node<T>(data);
        node.next = top;
        // 修改栈顶指针
        top = node;
        size++;
        return true;
    }

    @Override
    public T pop() {
        if(top == null){
            return null;
        }
        Node<T> node = top;
        // 修改栈顶指针
        top=node.next;
        size--;
        return node.data;
    }

    @Override
    public int length() {
        return size;
    }

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

    @Override
    public void clear() {
        top = null;
        size = 0;
    }

}