栈的实现（数组与链表实现）

栈（线性集合），后进先出（LIFO）方式进行处理，只在一端处理数据。
    push    添加一个元素到栈顶。
    pop     从栈顶移出一个元素
    peak    查看栈顶元素

package com.dengdi.arraystack;

public interface StackADT<T>{
    /**
     * 添加一个元素到栈顶部
     * @param element
     */
    public void push(T element);
    /**
     * 从栈顶移出一个元素
     * @return
     */
    public T pop();
    /**
     * 查看栈顶元素
     * @return
     */
    public T peek();
}

用数组来实现栈通过以下思想：
    (1)数组是一个对象引用的数组(其数据结构在栈实例化时确定)；
    (2)栈底总是在数组的索引0处；
    (3)栈的元素是按顺序并连续存储在数组中；
    (4)整数变量top保存了紧跟栈顶元素后的数组引号。

package com.dengdi.arraystack;
/**
 * 用数组来实现栈的功能
 * @author dengdi
 *
 * @param <T>
 */
public class ArrayStack<T> implements StackADT<T>{
    private int DEFAULT_LENGTH=100;
    private int point;
    private T[] stack;

    public ArrayStack() {
        point=0;
        stack=(T[]) new Object[DEFAULT_LENGTH];//不能直接创建泛型数组
    }

    @Override
    public void push(T element) {
        stack[point]=element;
        point++;
    }

    @Override
    public T pop() {
        point--;
        T result=stack[point];
        stack[point]=null;
        return result;
    }

    @Override
    public T peek() {

        return stack[point-1];
    }   
}

    链表是一种链式结构，其中的一个对象可以指向另一个对象，从而在链表中创建一个对象的线性次序。在链表中存储的对象通常泛称为该链表的结点。
    注意：需要一个单独的引用变量来表示链表的首结点。链表终止于其next引用为空的结点。
    链式结构是一种数据结构，它使用对象引用变量来创建之间的链接。

package com.dengdi.arraystack;
//链表定义类
public class LinkedNode<T> {
    private LinkedNode<T> next;//链接下个对象
    private T element;
    public LinkedNode() {
        this.next=null;
        this.element=null;
    }
    public LinkedNode(T element) {
        this.next=null;
        this.element = element;
    }
    public LinkedNode<T> getNext() {
        return next;
    }
    public void setNext(LinkedNode<T> next) {
        this.next = next;
    }
    public T getElement() {
        return element;
    }
    public void setElement(T element) {
        this.element = element;
    }

}

    链表的插入结点：
        结点可以被插入到链表的任意位置：链表前端、内部结点之间或链表尾端。
        在链表前端添加结点时，需要重新设置向整个链表引用，新添加结点的next引用被设置为指向链表的当前的结点。接着，指向链表前端的引用重新设置为指向这个新添加结点。

package com.dengdi.arraystack;  
/**
 * 用链表实现栈
 * @author dengdi
 *
 * @param <T>
 */

public class LinkedStack<T> implements StackADT<T>{
    private int count;
    private LinkedNode<T> top;
    @Override
    public void push(T element) {
        LinkedNode<T> temp=new LinkedNode<T>(element);
        temp.setNext(top);
        top=temp;
        count++;
    }

    @Override
    public T pop() {
        T result=top.getElement();
        top=top.getNext();
        count--;
        return result;
    }

    @Override
    public T peek() {
        T result=top.getElement();
        return result;
    }

}