链表 实现栈结构 java_Java之链表实现栈结构

package com.wzlove.stack;

import java.util.Iterator;

import java.util.NoSuchElementException;

/**

* 链表实现栈结构:栈的结构是先进后出,所以栈的结点也包括了两个部分

* 1.构造函数初始化栈

* 2.判空操作

* 3.栈的长度操作

* 4.入栈

* 5.出栈

* 6.返回最近入栈的元素

* 7.格式化输出

*

* @author WZLOVE

* @create 2018-07-14 21:53

*/

public class LinkedStack implements Iterable {

/**

* 表示栈的长度

*/

private int n;

/**

* 首节点

*/

private Node first;

/**

* 结点的结构

*/

private class Node{

private Item item;

private Node next;

}

/**

* 构造方法初始化栈

*/

public LinkedStack() {

first = null;

n = 0;

assert check();

}

/**

* 判断栈是否为空

* @return boolean类型,空为true,不空为false

*/

public boolean isEmpty(){

return first == null;

}

/**

* 返回栈的长度

* @return

*/

public int size(){

return n;

}

/**

* 入栈方法

* @param item 入栈的元素

*/

public void push(Item item){

// 保存旧的栈

Node oldFirst = first;

// 创建结点

first = new Node();

// 保存新的结点

first.item = item;

first.next = oldFirst;

// 修改栈的长度

n++;

assert check();

}

/**

* 出栈方法

* @return Item 出栈的元素

*/

public Item pop(){

if(isEmpty()){

throw new NoSuchElementException("栈为空,没有元素");

}

// 保存栈顶元素

Item item = first.item;

// 移动指针

first = first.next;

// 减小长度

n--;

assert check();

return item;

}

/**

* 返回最近入栈的元素

* @return Item 入栈的元素

*/

public Item peek(){

if(isEmpty()){

throw new NoSuchElementException("栈为空,没有元素");

}

return first.item;

}

/**

* 格式化输出

* @return

*/

@Override

public String toString() {

StringBuilder sb = new StringBuilder();

for(Item item : this){

sb.append(item + " ");

}

return sb.toString();

}

@Override

public Iterator iterator() {

return new ListIterator();

}

/**

* 迭代器类

* @return

*/

private class ListIterator implements Iterator{

/**

* 复制栈,进行遍历

*/

private Node current = first;

/**

* 判断有无更多元素,有返回true,没有返回false

* @return

*/

@Override

public boolean hasNext() {

return current != null;

}

/**

* 返回当前元素,移动指针

* @return

*/

@Override

public Item next() {

if(!hasNext()){

throw new NoSuchElementException("没有更多的元素");

}

Item item = current.item;

current = current.next;

return item;

}

@Override

public void remove() {

throw new UnsupportedOperationException("不支持该操作");

}

}

// check internal invariants

private boolean check() {

// check a few properties of instance variable 'first'

if (n < 0) {

return false;

}

if (n == 0) {

if (first != null) return false;

}

else if (n == 1) {

if (first == null) return false;

if (first.next != null) return false;

}

else {

if (first == null) return false;

if (first.next == null) return false;

}

// check internal consistency of instance variable n

int numberOfNodes = 0;

for (Node x = first; x != null && numberOfNodes <= n; x = x.next) {

numberOfNodes++;

}

if (numberOfNodes != n) return false;

return true;

}

/**

* 主方法进行测试

* @param args

*/

public static void main(String[] args) {

// 初始化栈

LinkedStack linkedStack = new LinkedStack<>() ;

// 输出栈的长度

System.out.println("初始化后栈的长度:"+linkedStack.size());

System.out.println("=====================================");

// 入栈

linkedStack.push("迪丽热巴");

linkedStack.push("李溪芮");

linkedStack.push("杨紫");

linkedStack.push("杨幂");

// 迭代器遍历

Iterator iterator = linkedStack.iterator();

while (iterator.hasNext()){

System.out.println(iterator.next());

}

System.out.println("====================================");

// 出栈

System.out.println(linkedStack.pop());

System.out.println("====================================");

// 输出栈的长度

System.out.println("经过操作后的长度为:" + linkedStack.size());

}

}