介绍了背包、队列和栈三种数据类型，以及如何通过链表实现。首先简单介绍下链表。
是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而顺序表相应的时间复杂度分别是O(logn)和O(1)。
使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。
链表中最简单的一种是单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向列表中的下一个节点，而最后一个节点则指向一个空值。
一个单向链表的节点被分成两个部分。第一个部分保存或者显示关于节点的信息，第二个部分存储下一个节点的地址。单向链表只可向一个方向遍历。
单向链表的常见操作：
private class Node
{
Item item;
Node next;
}
一种更复杂的链表是“双向链表”或“双面链表”。每个节点有两个连接：一个指向前一个节点，（当此“连接”为第一个“连接”时，指向空值或者空列表）；而另一个指向下一个节点，（当此“连接”为最后一个“连接”时，指向空值或者空列表）
双向链表也叫双链表。双向链表中不仅有指向后一个节点的指针，还有指向前一个节点的指针。这样可以从任何一个节点访问前一个节点，当然也可以访问后一个节点，以至整个链表。一般是在需要大批量的另外储存数据在链表中的位置的时候用。
在一个 循环链表中, 首节点和末节点被连接在一起。这种方式在单向和双向链表中皆可实现。
是一种不支持从中删除元素的集合数据类型，它的目的就是帮助用例收集元素并迭代遍历所有收集到的元素（用例也可以检查是否为空或者获取背包中元素的数量）。迭代的顺序不确定且与用例无关。
要理解背包的概念，可以想象一个非常喜欢收集弹子球的人。他将所有的弹子球都放在一个背包里，一次一个，并且不时在所有的弹子球中寻找某一颗拥有某种特点的弹子球。
需要实现如下API和迭代器Iterable。
代码：
下载地址https://github.com/tclxspy/Articles/blob/master/algorithm/Code/Bag.java
import java.util.Iterator;
import java.util.Scanner;
public class Bag<Item> implements Iterable<Item>
{
private Node first; // 第一结点
private int N;
private class Node
{
Item item;
Node next;
}
public void add(Item item)
{
Node oldfirst = first;
first = new Node();
first.item = item;
first.next = oldfirst;
N++;
}
public boolean isEmpty()
{
return first == null; // Or: N == 0.
}
public int size()
{
return N;
}
public Iterator<Item> iterator() {
return new ListIterator();
}
private class ListIterator implements Iterator<Item> //实现迭代器
{
private Node current = first;
public boolean hasNext()
{
return current != null;
}
public void remove()
{
//null
}
public Item next()
{
Item item = current.item;
current = current.next;
return item;
}
}
public static void main(String[] args)
{
Bag<Double> numbers = new Bag<Double>();
String data = "10.0 20.0 30.0 40.0";
Scanner sc = new Scanner(data);
while (sc.hasNext())
{
numbers.add(sc.nextDouble());
}
sc.close();
int N = numbers.size();
double sum = 0.0;
for (double x : numbers)
{
sum += x;
}
double mean = sum / N;
sum = 0.0;
for (double x : numbers)
{
sum += (x - mean)*(x - mean);
}
double std = Math.sqrt(sum/(N-1));
System.out.printf("Mean: %.2f\n", mean);
System.out.printf("Std dev: %.2f\n", std);
}
}
输出：
Mean: 25.00
Std dev: 12.91
队列，又称为伫列（queue），是先进先出（FIFO, First-In-First-Out）的线性表。在具体应用中通常用链表或者数组来实现。队列只允许在后端（称为rear）进行插入操作，在前端（称为front）进行删除操作。
需要实现如下API和迭代器Iterable。
代码：
下载地址https://github.com/tclxspy/Articles/blob/master/algorithm/Code/Queue.java
import java.util.Iterator;
import java.util.Scanner;
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; // Or: N == 0.
}
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()
{ // 从表头删除元素
Item item = first.item;
first = first.next;
if (isEmpty())
{
last = null;
}
N--;
return item;
}
public Iterator<Item> iterator()
{
return new ListIterator();
}
private class ListIterator implements Iterator<Item> //实现迭代器
{
private Node current = first;
public boolean hasNext()
{
return current != null;
}
public void remove()
{
//null
}
public Item next()
{
Item item = current.item;
current = current.next;
return item;
}
}
public static void main(String[] args)
{
Queue<Double> q = new Queue<Double>();
String data = "10.0 20.0 30.0 40.0";
Scanner sc = new Scanner(data);
while (sc.hasNext())
{
q.enqueue(sc.nextDouble());
}
sc.close();
int N = q.size();
for (int i = 0; i < N; i++)
{
System.out.println(q.dequeue());
}
}
}
输出：
10.0
20.0
30.0
40.0
堆栈是一种特殊的串列形式的数据结构，它的特殊之处在于只能允许在链接串列或阵列的一端（称为堆叠顶端指标，top）进行加入资料（push）和输出资料（pop）的运算。是一种基于后进先出（LIFO, Last-In-First-Out）策略的集合类型。
需要实现如下API和迭代器Iterable。
代码：
下载地址https://github.com/tclxspy/Articles/blob/master/algorithm/Code/Stack.java
import java.util.Iterator;
import java.util.Scanner;
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; // Or: N == 0.
}
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()
{ // 从栈顶删除元素
Item item = first.item;
first = first.next;
N--;
return item;
}
public Iterator<Item> iterator()
{
return new ListIterator();
}
private class ListIterator implements Iterator<Item> //实现迭代器
{
private Node current = first;
public boolean hasNext()
{
return current != null;
}
public void remove()
{
//null
}
public Item next()
{
Item item = current.item;
current = current.next;
return item;
}
}
public static void main(String[] args)
{
Stack<Double> stack = new Stack<Double>();
String data = "10.0 20.0 30.0 40.0";
Scanner sc = new Scanner(data);
while (sc.hasNext())
{
stack.push(sc.nextDouble());
}
sc.close();
for (Double value : stack)
{
System.out.println(value);
}
}
}
输出：
40.0
30.0
20.0
10.0
现在拥有两种表示对象集合的方式——数组和链表。Java内置了数组，链表也很容易使用Java标准方法实现。两者都非常基础，常常被称为顺序存储和链式存储。
