栈(顺序+链式) java实现

/article/1571885.html

栈的定义 :

栈（Stack）是限制仅在表的一端进行插入和删除运算的线性表。

(1)通常称插入、删除的这一端为栈顶 （Top），另一端称为栈底 （Bottom）。

(2)当表中没有元素时称为空栈。

(3)栈为后进先出（Last In First Out）的线性表，简称为 LIFO 表。

栈的修改是按后进先出的原则进行。每次删除（退栈）的总是当前栈中”最新”的元素，即最后插入（进栈）的元素，而最先插入的是被放在栈的底部，要到最后才能删除。



【示例】元素是以a1，a2，…，an的顺序进栈，退栈的次序却是an，an-1，…， a1。

2、栈的基本运算

（1）InitStack（S）

构造一个空栈S。

（2）StackEmpty（S）

判栈空。若S为空栈，则返回TRUE，否则返回FALSE。

（3）StackFull（S）

判栈满。若S为满栈，则返回TRUE，否则返回FALSE。

注意： 该运算只适用于栈的顺序存储结构。

（4）Push（S，x）

进栈。若栈S不满，则将元素x插入S的栈顶。

（5）Pop（S）

定义堆栈ADT

**

链表实现

**

package com.struct.StackADT;

public interface StackADT
{
public void push(Object element);   //压栈
public Object pop();    //出栈
public boolean isEmpty();   //是否是空栈
public int size();  //栈的大小
public Object peek();//返回栈顶对象的一个引用
public String toString();
}

在栈的一段添加和删除元素，在栈中维护一个指向栈顶的结点和一个count变量指示栈的大小：
private LinearNode top; //指向栈顶
private int count;//标记栈的大小
每次出栈和压栈在链表的表头：（也可以再表尾，实现方式不一样而已）
top--->元素1--->元素2--->元素3.........

具体实现以及测试代码：

package com.struct.StackADT;

public class LinkedStack implements StackADT
{
private LinearNode top; //指向栈顶
private int count;//标记栈的大小

public static void main(String[] args){
LinkedStack stack = new LinkedStack();
System.out.println("将0到10依次压栈");
for(int i = 0;i < 10;i++)
stack.push(i);
System.out.println("连续执行5次出栈操作");
for(int i = 0;i < 5;i++)
stack.pop();

System.out.println("栈为空吗？： " + stack.isEmpty());
System.out.println("栈的大小为： " + stack.size());
System.out.println("栈顶元素为： " + stack.top.getElement());
System.out.println("栈顶元素为： " + stack.peek());
}

public LinkedStack()
{
top = null;
count = 0;
}
public int size() {
return count;
}
public boolean isEmpty() {
return (size() == 0);
}
public void push(Object element) {
LinearNode node = new LinearNode(element);
node.setNext(top);
top = node;
count++;
}
public Object pop() {
if(isEmpty())
{
System.out.println("stack is empty!");
System.exit(1);
}
Object result = top.getElement();
top = top.getNext();
count--;
return result;
}
public Object peek() {
Object result =  top.getElement();
return result;
}
}

class LinearNode{
Object element;   //链表数据
LinearNode next;
public LinearNode(Object v){
this.element = v;
}
public void setNext(LinearNode node){
this.next = node;
}
public LinearNode getNext(){
return this.next;
}
public Object getElement(){
return this.element;
}
public void setElement(Object v){
this.element = v;
}

}
运行结果为：

将0到10依次压栈

连续执行5次出栈操作

栈为空吗？： false

栈的大小为： 5

栈顶元素为： 4

栈顶元素为： 4

数组实现：

栈底总是数组下标为0的位置，入栈出栈从数组下标的最后一个元素开始：

private Object[] contents;

private int top;//top标记下一个入栈的位置，同时也表示栈的容量大小，跟链式实现的count比较一下！！！

代码实现为：

package com.struct.StackADT;

public class ArrayStack
{
private Object[] contents;
private int top;//top标记下一个入栈的位置，同时也表示栈的容量大小，跟链式实现的count比较一下！！！
private static int SIZE = 10;

public ArrayStack()
{
contents = new Object[SIZE];
top = 0;
}
public void expand(){//借助于申请一个辅助空间,每次扩展容量一倍
Object[] larger = new Object[size()*2];
for(int index = 0;index < top;index++)
larger[index] =  contents[index];
contents = larger;
}
public int size() {
return top;
}
public boolean isEmpty() {
return (size() == 0);
}
public void push(Object element) {
//if(isEmpty())
//expand();
if(top == contents.length)
expand();
contents[top] = element;
top++;
}
public Object pop() {
if(isEmpty())
{
System.out.println("stack is empty!");
System.exit(1);
}
Object result = contents[top-1];
contents[top-1] = null;//出栈
top--;
return result;
/*书上这样写简便一点：：：
* top--;
* Object result = contents[top];
* contents[top] = null;*/
}
public Object peek() {
Object result;
if(isEmpty())
result = null;
else
result = contents[top-1];
return result;
}
public static void main(String[] args) {
ArrayStack stack = new ArrayStack();
System.out.println("将0到24依次压栈，然后连续10次出栈");
for(int i = 0;i < 25;i++)
stack.push(i);
for(int i = 0;i < 10;i++)
stack.pop();
System.out.println("栈的大小为： " + stack.size());
System.out.println("栈为空吗？： " + stack.isEmpty());
System.out.println("栈顶元素为： " + stack.peek());
}
}

运行结果为：

将0到24依次压栈，然后连续10次出栈
栈的大小为： 15
栈为空吗？： false
栈顶元素为： 14