java 顺序栈_栈的Java实现--顺序栈

栈的Java实现--顺序栈

栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据(最后一个数据被第一个读出来)。

栈是允许在同一端进行插入和删除操作的特殊线性表。允许进行插入和删除操作的一端称为栈顶(top)，另一端为栈底(bottom)；栈底固定，而栈顶浮动；栈中元素个数为零时称为空栈。插入一般称为进栈(PUSH)，删除则称为退栈(POP)。

由于堆栈数据结构只允许在一端进行操作，因而按照后进先出(LIFO, Last In First Out)的原理运作。栈也称为后进先出表。

堆栈数据结构使用两种基本操作：压入(push)和弹出(pop)：

压入：将数据放入堆栈的顶端(阵列形式或串行形式)，堆栈顶端top指标加一。

弹出：将顶端数据资料输出(回传)，堆栈顶端资料减一。

栈的实现方式也有顺序存储结构和链式存储结构。

下面是顺序存储结构实现的栈，即顺序栈

顺序栈的存储方式：

顺序栈的进栈：

对于顺序栈的进栈操作，只要将新的数据元素存入栈内，然后将记录栈内元素个数的size+1即可。同时要保证底层数组的长度可以容纳新的数据元素。

出栈：

让记录栈内元素个数的size-1

释放数组对原栈顶元素的引用

顺序栈的Java实现：

package com.liuhao.DataStructures;

import java.util.Arrays;

public class SequenceStack {

private final int DEFAULT_SIZE = 10;

private int capacity;// 保存当前数组长度

private int capacityIncrement = 0;// 数组长度不够时，程序每次增加的数组长度

private Object[] elementData;// 保存顺序栈的数据元素

private int size = 0;// 保存顺序栈中元素的个数

// 以默认长度创建空的顺序栈

public SequenceStack() {

capacity = DEFAULT_SIZE;

elementData = new Object[capacity];

}

// 以一个初始化元素创建顺序栈

public SequenceStack(T element) {

this();

elementData[0] = element;

size++;

}

/**

* 以指定长度创建顺序栈

*

* @param element

* 指定顺序栈中的第一个元素

* @param initSize

* 指定顺序栈的底层数组的长度

*/

public SequenceStack(T element, int initSize) {

this.capacity = initSize;

elementData = new Object[capacity];

elementData[0] = element;

size++;

}

/**

* 以指定长度创建顺序栈,同时指定底层数组增量

*

* @param element

* 指定顺序栈中的第一个元素

* @param initSize

* 指定顺序栈的底层数组的长度

* @param capacityIncrement

* 底层数组长度不够时，每次增加的增量

*/

public SequenceStack(T element, int initSize, int capacityIncrement) {

this.capacity = initSize;

this.capacityIncrement = capacityIncrement;

elementData = new Object[capacity];

elementData[0] = element;

size++;

}

// 获取顺序栈的长度

public int length() {

return size;

}

// 入栈

public void push(T element) {

this.ensureCapacity(size + 1);

// 将元素放到数组，同时让长度+1

elementData[size++] = element;

}

// 保证底层数组的长度

private void ensureCapacity(int minCapacity) {

// 如果数组的原有长度小于目前所需的长度

if (minCapacity > capacity) {

// 如果给定了数组长度增量

if (capacityIncrement > 0) {

while (minCapacity > capacity) {

// 不断的将capacity的长度增加，直到大于minCapacity

capacity += capacityIncrement;

}

}

// 若没有给定增量

else {

while (minCapacity > capacity) {

// 不断的将capacity加倍，直到大于minCapacity

capacity <<= 1;

}

}

// 将原来的数组的长度变为新的capacity

elementData = Arrays.copyOf(elementData, capacity);

}

}

// 出栈

public T pop() {

// 若当前为空栈，则弹出null

if (size == 0) {

return null;

}

T oldValue = (T) elementData[size - 1];

// 释放栈顶元素，同时将长度-1

elementData[--size] = null;

return oldValue;

}

// 获取栈顶元素

public T getPeek() {

// 若当前为空栈，则返回null

if (size == 0) {

return null;

}

return (T) elementData[size - 1];

}

// 判断是否为空

public boolean isEmpty() {

return size == 0;

}

// 情况顺序栈

public void clear() {

Arrays.fill(elementData, null);

size = 0;

}

public String toString() {

if (size == 0) {

return "[]";

} else {

StringBuilder sb = new StringBuilder("[");

for (int i = size - 1; i >= 0; i--) {

sb.append(elementData[i].toString() + ", ");

}

sb.append("]");

int length = sb.length();

// 删除多余的“,”和空格

return sb.delete(length - 3, length - 1).toString();

}

}

}

测试代码：

package com.liuhao.test;

import org.junit.Test;

import com.liuhao.DataStructures.SequenceStack;

public class SequenceStackTest {

@Test

public void test() {

// 以指定第一个元素和底层数组长度的方式构建顺序栈

SequenceStack sStack = new SequenceStack("我", 2);

System.out.println("当前所含内容" + sStack);

// 压入数据元素,元素格式大于了定义栈时底层数组的长度

sStack.push("是");

sStack.push("liuhao");

sStack.push("程序员");

// 发现是先入后出的方式打印的

System.out.println("当前所含内容" + sStack);

// 获取栈中元素个数

System.out.println("当前栈中元素个数是：" + sStack.length());

// 获取栈顶元素

System.out.println("当前栈顶元素是：" + sStack.getPeek());

// 弹出元素

System.out.println("弹出元素：" + sStack.pop());

// 发现是先入后出的方式打印的

System.out.println("当前所含内容" + sStack);

// 获取栈顶元素

System.out.println("当前栈顶元素是：" + sStack.getPeek());

// 获取栈中元素个数

System.out.println("当前栈中元素个数是：" + sStack.length());

// 判断是否为空栈

System.out.println("当前栈是否为空：" + sStack.isEmpty());

// 清空栈

sStack.clear();

// 判断是否为空栈

System.out.println("当前栈是否为空：" + sStack.isEmpty());

// 获取栈顶元素,空栈时返回null

System.out.println("当前栈顶元素是：" + sStack.getPeek());

// 获取栈中元素个数

System.out.println("当前栈中元素个数是：" + sStack.length());

// 空栈时进行弹出元素

System.out.println("弹出元素：" + sStack.pop());

}

}

测试结果：