背包，栈，队列的链表实现

定义背包，队列以及栈基本数据结构，

其中背包支持数据的添加以及查询操作，数据添加的顺序无关重要；

队列支持数据的先进先出FIFO

栈支持数据的后进先出LIFO

其基本的API如下所示：

                                   

最基本的数据结构有数组以及链表，可以使用基本结构来实现上述数据结构，这里采用链表形式来实现。

链表数据结构

可以使用链表来链式存储数据，每个节点含有数据属性以及指向下一个节点的指针

                                                                     

在链表的头部添加一个元素

                                                              

在链表的尾部添加一个元素

                                                                   

在链表的头部删除一个元素

                                                                             

使用链表来实现背包Bag

//背包数据结构  支持数据存储添加遍历操作
//不支持删除以及查找操作
//元素添加顺序不重要
public class Bag<Item> implements Iterable<Item> {
	
	private Node<Item> first;
	private int n;
	
	private static class Node<Item>{
		private Item item;
		private Node<Item> next;
	}
	
	public Bag(){
		first = null;
		n = 0;
	}
	
	public boolean isEmpty(){
		return first == null;
	}
	
	public int size(){
		return n;
	}
	
	public void add(Item item){
		Node<Item> oldfirst = first;
		first = new Node<>();
		first.item = item;
		first.next = oldfirst;
		n++;
	}

	@Override
	public Iterator<Item> iterator() {
		return new ListIterator<Item>(first);
	}
	
	private class ListIterator<Item> implements Iterator<Item> {
		
		private Node<Item> current;

		public ListIterator(Node<Item> first) {
			current = first;
		}
		
		@Override
		public void remove() {
			throw new UnsupportedOperationException();
		}

		@Override
		public boolean hasNext() {
			return current != null;
		}

		@Override
		public Item next() {
			if(!hasNext()) throw new NoSuchElementException();
			Item item = current.item;
			current = current.next;
			return item;
		}
		
	}
}

使用链表来实现队列Queue

//队列的链表实现
public class Queue<Item> implements Iterable<Item>{
	
	private Node first;
	private Node last;
	private int N;
	
	private class Node{
		Item item;
		Node next;
	}
	
	public boolean isEmpty() {
		return first == null;
	}

	public int size() {
		return N;
	}
	
	//在链表尾部插入一个元素
	public void enqueue(Item item){
		Node oldlast = last;
		last = new Node();
		last.item = item;
		last.next = null;
		if(isEmpty()){
			first = last;
		}else{
			oldlast.next = last;
		}
		N++;
	}
	
	public Item dequeue(){
		if(isEmpty()) return null;
		Item item = first.item;
		first = first.next;
		if(first == null)
			last = null;
		N--;
		return item;
	}

	@Override
	public Iterator<Item> iterator() {
		return new ListIterator<Item>(first);
	}
	
	private class ListIterator<Item> implements Iterator<Item> {

		private Node current;

		public ListIterator(Node first) {
			current = first;
		}

		@Override
		public void remove() {
			throw new UnsupportedOperationException();
		}

		@Override
		public boolean hasNext() {
			return current != null;
		}

		@Override
		public Item next() {
			if (!hasNext())
				throw new NoSuchElementException();
			Item item = (Item) current.item;
			current = current.next;
			return item;
		}
	}
}

使用链表来实现栈Stack

//链表方式实现栈
public class Stack<Item> implements Iterable<Item> {

	private Node first;
	private int N;

	private class Node {
		Item item;
		Node next;
	}

	public boolean isEmpty() {
		return first == null;
	}

	public int size() {
		return N;
	}

	public void push(Item item) {
		Node oldfirst = first;
		first = new Node();
		first.item = item;
		first.next = oldfirst;
		N++;
	}

	public Item pop() {
		if (isEmpty())
			return null;
		Item item = first.item;
		first = first.next;
		N--;
		return item;
	}

	@Override
	public Iterator<Item> iterator() {
		return new ListIterator<Item>(first);
	}

	private class ListIterator<Item> implements Iterator<Item> {

		private Node current;

		public ListIterator(Node first) {
			current = first;
		}

		@Override
		public void remove() {
			throw new UnsupportedOperationException();
		}

		@Override
		public boolean hasNext() {
			return current != null;
		}

		@Override
		public Item next() {
			if (!hasNext())
				throw new NoSuchElementException();
			Item item = (Item) current.item;
			current = current.next;
			return item;
		}
	}
}