单向链表实现数据结构中的栈

单向链表实现数据结构中的栈

/**
* 摘要：
* （一）实现的是数据结构中的栈
* （二）程序使用的语言是JAVA语言
* （三）实现栈的基本操作有：
* 1、插入
* 2、删除
* 3、获取栈的长度
* 4、判断栈是否为空
* 5、建一个栈
* （四）基本的思想是:采取反向的单向链表，反向的单向链表和单向链表的不同之处是单向链表只有后继，而反向的单向链表只有前驱
* （五）实现单链表的操作方式是:用递归调用
* 知识扩充：
* （一）在程序的编写过程中设定了三个变量
* 1、private int top = 0;//栈顶指针
* 2、private int base = 0;//栈底指针
* 3、private Node baseNode = null;//存储栈底指针指向的内存
* （二）base始终指向栈底，作为空栈的标识有两种方法，一种是top==base，另一种是baseNode是否为空，每当插入一个新的元素，指针top
* 增1，删除一个元素，指针top减1，直到top==base.
* （三）程序中定义了三个类，一个是Node类，一个是Army类,一个是ArmyOperate类
*/

import java.util.ArrayList;
import java.util.List;

public class Army {
private int top = 0;// 栈顶指针
private int base = 0;// 栈底指针
private Node baseNode = null;// 存储栈底指针指向的内存

public Army(int base) {
    this.setBase(base);
    this.setTop(base);
}

public Army(List<Object> list) {
    this.setBase(list.size());
    this.setTop(list.size());
    for (Object object : list) {
        add(object);
    }
}

public void add(Object object) {
    if (getBaseNode() == null) {// 是空栈时
        Node node = new Node(object);
        setBaseNode(node);
    } else {
        getBaseNode().addNode(object);
    }
    setTop(getTop() - 1);
}

public Object delect() {
    return getBaseNode() == null ? false : this.getBaseNode().delectNode();
}

public Object getTopData() {
    return getBaseNode() == null ? false : this.getBaseNode().getTopNode();
}

class Node {
    private Object data;
    private Node prior;

    public Node(Object data) {
        super();
        this.data = data;
    }

    public void addNode(Object object) {

        if (getPrior() == null) {
            Node node = new Node(object);
            setPrior(node);
        } else {
            this.prior.addNode(object);
        }
        setTop(getTop() - 1);
    }

    public Object delectNode() {
        Object object = null;
        if (this.getPrior() != null) {
            if (this.getPrior().getPrior() == null) {
                object = this.getPrior().getData();
                this.setPrior(null);
                return object;
            }
            setTop(getTop() + 1);
            return this.getPrior().delectNode();

        } else {
            object = getBaseNode().getData();
            setBaseNode(null);
        }
        return object;
    }

    public Object getTopNode() {
        Object object = null;
        if (getPrior() == null) {
            object = getData();
        } else {
            object = this.getPrior().getTopNode();
        }
        return object;
    }

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public Node getPrior() {
        return prior;
    }

    public void setPrior(Node prior) {
        this.prior = prior;
    }
}

public int getTop() {
    return top;
}

public void setTop(int top) {
    this.top = top;
}

public int getBase() {
    return base;
}

public void setBase(int base) {
    this.base = base;
}

public Node getBaseNode() {
    return baseNode;
}

public void setBaseNode(Node baseNode) {
    this.baseNode = baseNode;
}

}

public class ArmyOperate {
private Army army;

/**
 * 构造一个空栈
 */
public ArmyOperate(int base) {
    // TODO Auto-generated constructor stub
    if (base < 1) {// 如果栈的空间小于1，这个栈也就没有存在的必要性
        System.out.println("ERROR！");
    } else {
        this.army = new Army(base);
    }
}

/**
 * 生成一个不为空的栈
 */
public ArmyOperate(List<Object> list) {
    super();
    if (list.size() < 1) {// list.size()取得集合的长度，如果小于1，这个栈也就没有存在的必要性
        System.out.println("ERROR！");
    } else {
        this.army = new Army(list);
    }
}

/**
 * 若栈为空返回true，否则返回false
 */
public boolean StackEmpty() {
    return this.army.getBase() == this.army.getTop() ? true : false;
}

/**
 * 返回栈的长度
 */
public int StackLength() {
    return this.army.getBase();

}

/**
 * 若栈不为空则返回栈顶元素，否则返回false
 */
public Object GetTop() {
    return this.army.getBase() == this.army.getTop() ? false : this.army
            .getTopData();
}

/**
 * 插入元素为新的栈顶元素
 */
public void Push(Object object) {
    this.army.add(object);
}

/**
 * 若栈不为空则删除栈顶元素，返回true，否则返回false
 */
public Object Pop() {

    return this.army.delect();
}

public static void main(String[] args) {
    List<Object> list = new ArrayList<Object>();
    list.add("yi");
    list.add("er");
    list.add("san");
    list.add("si");
    list.add("wu");
    ArmyOperate armyOperate = new ArmyOperate(list);

    System.out.println(armyOperate.Pop());
    System.out.println(armyOperate.Pop());
    System.out.println(armyOperate.Pop());
    armyOperate.Push("hu");
    System.out.println(armyOperate.Pop());
    System.out.println(armyOperate.Pop());
    System.out.println(armyOperate.Pop());
    System.out.println(armyOperate.Pop());

}

}