栈的特点以及实现

一：栈的特点

         后进者先出，先进者后出，这就是典型的“栈”结构。栈是一种操作受限的数据结构，只允许在一端插入和删除数据。

二：栈的实现

         栈可以用数组，也可以用链表实现。数组实现的栈叫做顺序栈，链表实现的栈叫做链式栈。

         以下用java实现一个顺序栈

         

public class ArrayStack{
    private String[] items;             //数组
    private int n;                      //数组的大小也就是栈的大小
    private int count;                  //栈中的元素个数

    public ArrayStack(int n){           //初始化为n个元素的栈
        this.items = new String[n];
        this.n = n;
        this.count = 0;
    }
    
    public boolean push(String item){    //入栈操作
        if(count == n) return false;     //元素个数为栈的大小，即栈满了，入栈失败直接返回false
        items[count] = item;             //将元素放在下标为count的位置，并且count加一
        ++count;
        return true;
    }

    public String pop(){                 //出栈操作
        if(count == 0) return null;      //元素个数为0，即栈中没有元素，返回null
        String temp = items[count-1];    //返回下标为count-1位置的元素，并且count减一
        --count;
        return temp;
    }
}

      以下用链表实现一个链式栈

/**
 * 基于链表实现的栈。
 *
 */
public class StackBasedOnLinkedList {
    private Node top = null;

    public void push(int value) {
        Node newNode = new Node(value, null);
        // 判断是否栈空
        if (top == null) {
            top = newNode;
        } else {
            newNode.next = top;
            top = newNode;
        }
    }

    /**
     * 我用-1表示栈中没有数据。
     */
    public int pop() {
        if (top == null) return -1;
        int value = top.data;
        top = top.next;
        return value;
    }

    public void printAll() {
        Node p = top;
        while (p != null) {
            System.out.print(p.data + " ");
            p = p.next;
        }
        System.out.println();
    }

    private static class Node {
        private int data;
        private Node next;

        public Node(int data, Node next) {
            this.data = data;
            this.next = next;
        }

        public int getData() {
            return data;
        }
    }
}

  三：复杂度分析

         不管是顺序栈还是链式栈，我们存储数据只需要一个大小为 n 的数组就够了。在入栈和出栈过程中，只需要一两个临时变量存储空间，所以空间复杂度是 O(1)。不管是顺序栈还是链式栈，入栈、出栈只涉及栈顶个别数据的操作，所以时间复杂度都是 O(1)。