数据结构之一：栈的实现

基本介绍

栈 (Stack)是一种后进先出(last in first off，LIFO)的数据结构。

栈的实现

栈是一种后进先出的数据结构，对于Stack 咱们但愿至少要对外提供如下几个方法：

Stack<T>();                    //建立一个空的栈
void Push(T s);                //往栈中添加一个新的元素
T Pop();                       //移除并返回最近添加的元素
boolean IsEmpty();             //栈是否为空
int Size();                    //栈中元素的个数

具体实现有两种方式：基于数组的实现与基于链表的实现。

基于数组的实现

import java.util.Arrays;
public class StackImplementByArrays<T>
{   
    Object[] item;
    static final int DEFAULT_CAPACITY=10;
    int CAPACITY;
    int size;
    static final float Max_SIZE_RATIO=(float) 0.75;
    static final float Min_SIZE_RATIO=(float) 0.25;
    public StackImplementByArrays()
    {
        size=0;
        item=new Object[DEFAULT_CAPACITY];
        CAPACITY=DEFAULT_CAPACITY;
    }
    public StackImplementByArrays(int capacity)
    {
        super();
        size=0;
        item=new Object[10];
        CAPACITY=capacity;
    }
    public void resize(int re_size)
    {
            Object[] tem=new Object[re_size];   
            for(int i=0;i<size;i++)
            {
                tem[i]=item[i];
            }
            item=tem;
    }
    public void push(T ele)
    {   
        if(size>=CAPACITY*Max_SIZE_RATIO)
        {
            CAPACITY=CAPACITY<<2;
            resize(CAPACITY);
        }
        item[this.size]=ele;
        this.size++;
    }
    public T pop()
    {
        if(!isEmpty())
        {
            if(size<=CAPACITY*Min_SIZE_RATIO)
            {
                CAPACITY=CAPACITY>>2;
                resize(CAPACITY);
            }
            T tem = (T) item[this.size-1];
            this.size--;
            return tem; 
        }
        else
        {
            throw new ExceptionInInitializerError("The stack is Empty");
        }
    }
    public boolean isEmpty()
    {
        if(0==this.size)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    public int size()
    {
        return this.size;
    }
}

分析：
1. Pop和Push操做在最坏的状况下与元素个数成比例的N的时间，时间主要花费在扩大或者缩小数组的个数时，数组拷贝上。
2. 元素在内存中分布紧凑，密度高，便于利用内存的时间和空间局部性，便于CPU进行缓存，较LinkList内存占用小，效率高。