用java实现单链表模拟栈

上次看到一篇文章说1和-1谁更基础？链表、栈、队列谁更基础？

当时我尚不知链表怎么转换为栈。只了解栈链表的一些基本运用，今天我就试试用链表怎么模拟栈。

栈他是一头操作的，先进后出，而链表是两段操作的中间也可以操作，我们把链表封装成一端操作的不就是基本实现栈了吗？！至少表面上。

 

下面就是自己用链表简单的实现了一下，不知道对不对

链表类：

package com.wwy.moni;

public class Link<E> 
{
	
	private transient int size = 0;
	private Node<E> head = new Node<E>();
	
	public Link()
	{
		head.next = head;
	}
	
	public Link(E data)
	{
		head.data = data;
		head.next = head;
	}

	/**
	 * 删除值为newVal的节点
	 * @param newVal
	 */
	public  void remove(E newVal) {
		Node<E> temp = head;
		
		//循环查找值为newVal的节点
		for(int i = 0;i < size;i++)
		{
			E data = temp.data;
			if(newVal.equals(data))
			   break;
			temp = temp.next;
		}
		System.out.println(temp.data);
		//找到值为newVal的节点temp,继续查找该节点的前一个节点
		Node<E> courrent = temp;
		
		//判断是不是尾节点
		if(temp.next == null)
		{
			courrent = this.getTailPrevious();
			//断开链接，
			courrent.next = null;
			size--;
		}
		else
		{
			//不是尾节点，查找temp（要删除的节点）的前一个节点
			//System.out.println(432);
			//怎么查？？？？？？？？？？？、
			Node<E> prev = head;
			//找到的prev就是要删除节点的前一个节点
			for(int i = 0; i < size;i++)
			{
				if(prev == temp)
				{
					prev = this.getNode(i - 1);
					break;
				}
				prev = prev.next;
			}
			
			courrent = prev;
			//断开链接，也就是把找到的前一个节点的后一个节点指向为要删除节点的下一个节点
			courrent.next = temp.next;
			//并断开要删除节点与后一个节点的链接
			temp.next = null;
			size--;
		}
	}
	
	//删除尾节点
	public E remove()
	{
        Node<E> temp = head;
		
		//循环查找值为newVal的节点
		for(int i = 0;i < size - 1;i++)
		{
			temp = temp.next;
		}
		E e = temp.data;
		//断开链接，
		temp.next = null;
		size--;
		return e;
	}
	
	/**
	 * 查找倒数第二个节点
	 */
	private Node<E> getTailPrevious()
	{
		Node<E> temp = head;
		int i = 0;
		//循环找到当前链表的尾节点
		do
		{
			Node<E> current = temp;
		   temp = temp.next;
		   i++;
		   if(current == null)
		   {
			   break;
		   }
		}while(i < size-2);
		return temp;
	}

	/**
	 * 在尾节点插入值为newVal的节点
	 * @param newVal
	 */
	public  void add(E newVal) {
		if(size == 0)
		{
			head.data = newVal;
		}
		else{
			Node<E> temp = this.getTailPrevious().next;
			//创建值为newVal的节点
			Node<E> insert = new Node<E>(newVal);
			//将新创建的节点链接到尾部
			temp.next = insert;
		}
		//链表长度加1
		size++;
	}

	/**
	 * 查找指定位置的节点
	 * @param index
	 * @return
	 */
	public Node<E> getNode(int index){
		//从头结点开始遍历
		Node<E> temp = head;
		
		for(int i = 0;i < size;i++)
		{
			if(i == index){
				return temp;
			}
			temp = temp.next;
		}
		if(temp == null)
			throw new NullPointerException();
		return null;
	}
	
	/**
	 * 返回链表的大小
	 * @return
	 */
	public int size()
	{
		return size;
	}

	/**
	 * 节点类
	 * @author wWX161568
	 *
	 */
	public static class Node<E>
	{
		Node<E> next;
		E data;
		
		public Node()
		{
		}
		public Node(E data)
		{
			this.data = data;
		}
	}

}

模拟栈类

package com.wwy.moni;

public class LinkStack<E> {
	
	private Link<E> link = null;
	
	public LinkStack()
	{
		link = new Link<E>();
	}
	
	public void pusk(E e)
	{
		link.add(e);
	}
	
	public E pop()
	{
		return link.remove();
	}
	
	public E peek()
	{
		return link.getNode(link.size() - 1).data;
	}
}

也可以用java封装好的集合来实现模拟，那就简单了，我感觉也没啥意思

package com.wwy.linked;

import java.util.ArrayList;
import java.util.List;
/**
 * 用java现有的集合数组，模拟Stack
 * @author wWX161568
 *
 * @param <E>
 */
public class ArrayIntoStack<E> {

	private List<E> lst = null;
	
	public ArrayIntoStack()
	{
		lst = new ArrayList<E>();
	}
	
	public ArrayIntoStack(int n)
	{
		lst = new ArrayList<E>(n);
	}
	
	public E pop()
	{
		E e = lst.remove(lst.size() - 1);
		return e;
	}
	
	public E peek()
	{
		E e = lst.get(lst.size() - 1);
		return e;
	}
	
	public E pusk(E e) 
	{
		lst.add(e);
		return e;
	}
	
	public boolean isEmpty()
	{
		return lst.size() == 0;
	}
	
	public int size()
	{
		return lst.size();
	}
	
}

 

package com.wwy.linked;

import java.util.LinkedList;

public class LinkedIntoStack<E> {

	private LinkedList<E> link = null;
	
	public LinkedIntoStack()
	{
		link =  new LinkedList<E>();
	}
	
	public boolean pusk(E e)
	{
		return  link.add(e);
	}
	
	public E pop()
	{
		return link.removeLast();
	}
	
	public E peek()
	{
		return link.getLast();
	}
	
	public boolean isEmypt()
	{
		return link.size() == 0;
	}
	
	public int size()
	{
		return link.size();
	}
}