栈（Stack） 原

ADT Stack{
  数据对象：D={ai|ai∈element,i=1,2,3……,n,n≥0}
  数据关系：R={<ai-1,ai>|ai-1,ai∈D,约定an端为栈顶，a1端为栈底}
  基本操作：
  init(int s);			//构造一个空栈s
  clear();				//清空栈
  isEmpty();			//判断堆栈是否为空
  isFull();				//判断栈是否满。
  peek();				//获取栈顶元素但不出栈
  push(Object o);		//元素o入栈
  pop();				//栈顶元素出栈
  getSize();			//获取元素个数。

}ADT Stack

/**
 * 使用数组实现堆栈
 * @author 星汉
 *
 */
public class ListStack {

    private Object[] elements;//数组容器
    private int size;//元素个数
    /**
     * 默认大小为32的堆栈
     */
    public ListStack() {
        this.elements=new Object[32];
        this.size=0;
    }
    /**
     * 清空栈
     * @return 成功返回true
     */
    public boolean clear() {
        for(int i=size-1;i>=0;i--,size--) {
            elements[i]=null;
        }
        return size<=0;
    }
    /**
     * 判断栈是否为空
     * @return 为空返回true
     */
    public boolean isEmpty() {
        return size==0;
    }
    /**
     * 判断是否满栈
     * @return 栈满返回true
     */
    public boolean isFull() {
        return size==elements.length;
    }
    /**
     * 获取栈顶元素，但不删除栈顶元素
     * @return object 栈顶元素
     */
    public Object peek() {
        if(size!=0) {
            return elements[size-1];
        }
        return null;
    }
    /**
     * 入栈
     * @param o 入栈元素
     */
    public void push(Object o) {
        if(size<elements.length) {
            elements[size]=o;
            size++;
        }else {
            System.out.println("上溢");
        }
    }
    /**
     * 出栈
     * @return 栈顶元素
     */
    public Object pop() {
        if(size>0) {
            Object tmp = elements[size-1];
            elements[size-1]=null;
            size--;
            return tmp;
        }else {
            System.out.println("下溢");
            return null;
        }
    }
    /**
     * 返回栈中元素个数
     * @return
     */
    public int getSize() {
        return size;
    }
}

/**
 * 数制转换
 * @author 星汉
 *
 */
public class TransportNum {

    public static void main(String[] args) {
        ListStack ls=new ListStack();//利用上面实现的栈
        int n=20;//未知数
        int remainder=0;//余数
        int d=2;//进制数
        while(n!=0) {
            remainder=n%d;
            n=n/d;
            ls.push(remainder);//将余数入栈
        }
        while(!ls.isEmpty()){
            System.out.print(ls.pop());
        }
    }
}

    public static int recursion(int n) {
        if(n<=1) {
            return 1;
        }else {
            return n*recursion(n-1);
        }
}

    public static void main(String[] args) {
        //使用之前实现的链式堆栈
        LinkedStack ls=new LinkedStack();
        int num=10;
        while(num!=0) {
            ls.push(num);
            num--;
        }
        int product=1;
        while(!ls.isEmpty()) {
            product*=(int)ls.pop();
        }
        System.out.println(product);
}