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

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

/**

* 摘要：

* （一）实现的是数据结构中的栈

* （二）程序使用的语言是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());

}

}