数据结构之-栈（Java实现）

理解

栈是仅在末尾进行插入和删除操作的线性表。具有LIFO(last in first out)的特性。

也就是说，栈是一种特殊的线性表。

点击查看大图



在《大话数据结构》中，作者主要给了两种实现方式：基于数组和基于链表的实现。因为栈是一种特殊的线性表，我们只需要对顺序存储和链式存储做一些修改，只让其操作头部和尾部，就可以达到目的。

基于数组的实现（Java实现）

实现代码

//栈(数组实现)
public class MyStack {
//大小
private int size;
//栈的最大容量
private int maxSize;
//默认最大容量为10
private static final int DEFAULT_MAX_SIZE = 10;
//数组（用来保存数据）
String stack[];

public MyStack(int maxSize) {
this.maxSize = maxSize;
stack = new String[maxSize];
}

public MyStack() {
this(DEFAULT_MAX_SIZE);
}

public void push(String s) {
if (size >= maxSize) {
throw new IndexOutOfBoundsException("栈已经满了");
}
stack[size] = s;
size++;
look();
}

public  String pop(){
String rs = stack[size-1];
stack[size-1]=null;
size--;
look();
return rs;
}

public void clear(){
for (int i = 0; i < size; i++) {
stack[i] = null;
}
size=0;
look();
}

public int getSize() {
return size;
}

private void look() {
System.out.println("");
for (int i = 0; i < maxSize; i++) {
System.out.print(stack[i]+" ");
}
}
}

演示

public class Main {
public static void main(String[] args) {
MyStack stack = new MyStack(4);
stack.push("1");
stack.push("2");
stack.push("3");
stack.push("4");
stack.pop();
stack.pop();
stack.push("a");
stack.push("b");
}
}

结果：

1 null null null
1 2 null null
1 2 3 null
1 2 3 4
1 2 3 null
1 2 null null
1 2 a null
1 2 a b

基于链表的实现（Java实现）

实现代码

//栈(链表实现)
public class MyStackNode {
//栈顶的节点
private Node top;
//大小
private int size;
//栈的最大容量
private int maxSize;
//默认最大容量为10
private static final int DEFAULT_MAX_SIZE = 10;

public MyStackNode(int maxSize) {
this.maxSize = maxSize;
}

public MyStackNode() {
this(DEFAULT_MAX_SIZE);
}

//将数据添加到栈中
public void push(String s) {
if (size >= maxSize) {
throw new IndexOutOfBoundsException("栈已经满了");
}
Node node = new Node(s, top);
top = node;
look();
size++;
}

/**
* 移除栈顶的数据
*/
public String pop() {
if (top == null)
return null;
Node oldTop = top;
Node newTop = top.next;
String rs = oldTop.s;
oldTop.next = null;
oldTop.s = null;
oldTop = null;
top = newTop;
look();
size--;
return rs;
}

/**
* 清空栈中的而数据
*/
public void clear() {
Node node = top;
while (node != null) {
Node newTop = node.next;
node.next = null;
node.s = null;
node = newTop;
}
look();
size=0;
}

class Node {
public String s;
public Node next;

public Node(String s, Node next) {
this.s = s;
this.next = next;
}

public void setNext(Node next) {
this.next = next;
}
}

//查看数据
private void look(){
System.out.println("");
Node node = top;
while (node != null) {
System.out.print(node.s + " ");
node = node.next;
}
}

public int getSize() {
return size;
}
}

演示

public class Main {
public static void main(String[] args) {
MyStackNode stack = new MyStackNode(4);
stack.push("1");
stack.push("2");
stack.push("3");
stack.push("4");
stack.pop();
stack.pop();
stack.push("a");
stack.push("b");
}
}

结果（数组实现中查看方式是从底部开始查看，这里是从顶部开始查看，所以视觉顺序不一致）

1
2 1
3 2 1
4 3 2 1
3 2 1
2 1
a 2 1
b a 2 1

两栈共享空间

这种栈的实现逻辑比较奇怪，为了节约空间而无所不用其极。我看了半天没想明白：为了节约空间，为啥不一开始就把开辟的内存空间尽可能的压缩，却要用这种奇怪的方式来节约空间？这种哲学上的思考就不去深究了，这里给出实现的代码，各位可以参考参考。

实现代码

//两栈共享空间
public class ShareStack {
//大小
private int size;
//栈的最大容量
private int maxSize;
//默认最大容量为10
private static final int DEFAULT_MAX_SIZE = 10;
//数组（用来保存数据）
private String[] stack;
private int leftTop = -1;
//右侧栈顶的索引
private int rightTop;

public ShareStack(int maxSize) {
this.maxSize = maxSize;
stack = new String[maxSize];
rightTop = maxSize;
}

public ShareStack() {
this(DEFAULT_MAX_SIZE);
}

public void pushLeft(String s) {
if (leftTop + 1 >= rightTop) {
throw new IndexOutOfBoundsException("栈已经满了");
}
leftTop++;
stack[leftTop] = s;
size++;
look();
}

public void pushRight(String s) {
if (leftTop + 1 >= rightTop) {
throw new IndexOutOfBoundsException("栈已经满了");
}
rightTop--;
stack[rightTop] = s;
size++;
look();
}

public String popLeft() {
if (leftTop == -1)
return null;
String rs = stack[leftTop];
stack[leftTop] = null;
leftTop--;
size--;
look();
return rs;
}

public String popRight() {
if (rightTop == maxSize)
return null;
String rs = stack[rightTop];
stack[rightTop] = null;
rightTop++;
size--;
look();
return rs;
}

public void clearLeft() {
int leftSize = leftTop + 1;
for (int i = 0; i < leftSize; i++) {
stack[i] = null;
}
size = size - leftSize;
leftTop = -1;
look();
}

public void clearRight() {
int rightSize = maxSize - rightTop;
for (int i = maxSize - 1; i >= rightTop; i--) {
stack[i] = null;
}
size = size - rightSize;
rightTop = maxSize;
look();
}

public int getSize() {
return size;
}

private void look() {
System.out.println("");
for (int i = 0; i < maxSize; i++) {
System.out.print(stack[i] + " ");
}
}
}

演示

public class Main {
public static void main(String[] args) {
ShareStack stack = new ShareStack(4);
stack.pushLeft("1");
stack.pushLeft("2");
stack.pushLeft("3");
stack.pushLeft("4");
stack.popLeft();
stack.popLeft();
stack.pushRight("a");
stack.pushRight("b");
}
}

结果

1 null null null
1 2 null null
1 2 3 null
1 2 3 4
1 2 3 null
1 2 null null
1 2 null a
1 2 b a

结语

数据结构-线性表之顺序储存（Java实现）和 数据结构-线性表之单链表（Java实现）明白的话，栈是很好实现的；因为栈是一种特殊的线性表

转载请标明出处：http://blog.csdn.net/qq_26411333/article/details/51922484