class Node {

Object item; Node next;

  Node (Object v) {

item = v; next = null;

}

}

头指针，空尾指针

初始化：head = null;

在x后插入t：

if ( x == null)

{ head = t; head.next = null; }

else { t.next = x.next; x.next = t; }

移走x之后的结点：t = x.next; x.next = t.next;

循环遍历：for ( t = head; t != null; t = t.next )

检查链表是否为空：if ( head == null )

空头结点，空尾指针

初始化：head = new Node(); head.next = null;

在x后插入t：t.next = x.next; x.next = t;

移走x之后的结点：t = x.next; x.next = t.next;

循环遍历：for ( t = head.next; t != null; t = t.next )

检查链表是否为空：if ( head.next == null )

空头结点，空尾结点

初始化：head = new Node(); z = new Node(); head.next = z; z.next = z;

在x后插入t：t.next = x.next; x.next = t;

移走x之后的结点：t = x.next; x.next = t.next;

循环遍历：for ( t = head.next; t != z; t = t.next )

检查链表是否为空：if ( head.next == z )

循环链表

第一次插入：head.next = head;

在x后插入t：t.next = x.next; x.next = t;

移走x之后的结点：t = x.next; x.next = t.next;

循环遍历：t = head; do { t = t.next; } while ( t != head );

检查是否只有一个数据项：if ( head.next == head )

堆栈

数组实现

class Stack {

  private Object[] s;

  private int n;

  Stack ( int maxN ) {

    s = new Object[maxN]; n = 0;

}

boolean isEmpty() { return ( n == 0 ); }

void push ( Object item ) { s[n++] = item; }

Object pop() {

  Object t = s[--n]; s[n] = null; return t;

}

}

链表实现

class Stack {

  private Node head;

  private class Node {

Object item; Node next;

Node ( Object item, Node next ) {

  this.item = item; this.next = next;

}

}

Stack ( Object maxN ) { head = null; }

boolean isEmpty() { return ( head ==null ); }

void push ( Object item ) { head = new Node(item, head); }

Object pop() {

  Object v = head.item;

  Node t = head.next;

  head = t;

  return v;

}

}

FIFO队列的链表实现

class Queue {

  private class Node {

Object item; Node next;

Node ( Object item ) {

  this.item = item; this.next = null;

}

}

Private Node head, tail;

Queue ( Object max ) { head = null; tail = null; }

boolean isEmpty() { return ( head ==null ); }

void put ( Object item ) {

  Node t = tail;

  tail = new Node(item);

  if ( empty() )

    head = tail;

  else t.next = tail

}

Object get() {

  Object v = head.item;

  Node t = head.next;

  head = t;

  return v;

}

}

在很多实际应用中，我们都不允许存在数据项重复的情况，需要对用户提交的重复数据进行合适的处理。让用户保证不提交重复的数据可以避免这种情况的发生，但显然这种方法并不实际，既然使用ADT就是为了给使用它的程序员提供简单明了的数据类型解决方案，那么我们就应该在ADT中来解决这个问题。以队列为例，一般可以通过两种策略来处理这个问题：

1.        放弃新输入的数据项：当最新放入队列中的数据项已经在队列中时，放弃当前输入的数据项。

2.        放弃旧的数据项，保存新输入的数据项：当最新放入队列中的数据项已经在队列中时，放弃已经存在于队列中的数据项，保存当前放入的数据项。

数组和链表是数据结构中老生常谈的问题，在指针或是引用这些概念出来之前，数组就能用来实现链表的功能。这里所说的链表指的就是用指针或对象的引用来设计的链表。

在实际的应用开发中，数组由于它天生的种种特性(参考《Java容器分析—数组》)，更多的会被开发人员所想到用到，但所有的数据结构都有它特定的适用场合。众所周知，数组和链表最大的区别在于，使用数组能够快速访问数组中的每个元素，而使用链表可以方便的操纵每个数据项。下面通过两个很有趣的例子说明了它们各自的区别与优势。

虽然在JDK中Java提供了List接口及其接口的实现(ArrayList/LinkedList)对链表数据结构提供了有力的支持，具体可以参考《Java容器分析—List和Set》但下面数学上关于Josephus问题的实现仅使用了自定义的最简单的链表结构。

/**

 * 根据命令行输入的N值，计算出所有小于N的素数

 * 是素数将数组元素值设为true，否则设为false

 */

class ArrayApp {

  public static void main(String[] args) {

int N = Integer.parseInt(args[0]);

boolean[] a = new boolean[N];

for (int i = 2; i < N; i++)

  a[i] = true;

for (int i = 2; i < N; i++)

  if (a[i] != false)

    for (int j = i; j*i < N; j++)

      a[i*j] = false;

for (int i = 2; i < N; j++)

  if (a[i])

    System.out.println(“” + i);

}

}

/**

 * N个有编号的小球围成一圈，每个M-1个就拿去一个小球，计算最后剩下的球的位置

 */

class LinkApp {

  static class Node {

int value;

Node next;

Node (int v) { v = value; }

}

public static void main(String[] args) {

  int N = Integer.parseInt(args[0]);

  int M = Integer.parseInt(args[1]);

  Node first = new Node(1);

  Node x = first;

  for (int i = 2; i <= N; i++)

    x = (x.next = new Node(i));

  x.next = first;

  while (x != x.next) {

    for (int i = 1; i < M; i++)

      x = x.next;

    x.next = x.next.next;

}

System.out.println(“最后剩下的小球：” + x.value);

}

}

要想充分理解算法并有效地应用于实际问题，关键是对算法的分析。通常我们可以利用实验对比分析、数学方法来分析算法。实验对比分析很简单，两个算法相互比较，它们都能解决同一问题，在相同环境下，哪个算法的速度快我们一般就会认为这个算法性能更好。数学方法能将算法分析的更为细致，能在严密的逻辑推理基础上判断算法的优劣，但在完成实际项目过程中，我们很多时候都不能去做这种严密的论证与推断，因为我们不是在完成一道数学难题，也不是数学领域的专家，将大量的时间花费在公式的计算与证明上会导致整个项目进度缓慢、成本过高，因此，在算法设计中，我们往往采用能近似表达性能的方法来展示某个算法的性能指标。例如，计算机对n²和n²+2n的响应速度，当n比较大的时候几乎一样没什么区别，我们便可直接认为后者算法的复杂度为n²。在分析算法时，隐藏细节的数学表示法成为大O记法，它可以帮助我们简化算法复杂度的许多细节，提取主要成分，这和遥感图像处理中的主成分分析思想相近。

基于算法复杂度简化表达的思想基础上，我们通常会对算法进行最坏情况分析和平均情况分析。对于一个给定的算法，如果能保证它的最坏情况下的性能依然不错当然很好，但是在某些情况下，程序的最坏情况算法的运行时间和实际情况的运行时间相差很大，在实际应用中我们几乎不会碰到最坏情况下的输入，那么此时进行最坏情况分析显得有些画蛇添足，特别是分析最坏情况算法会花费大量精力的时候。算法的平均情况分析可以帮助我们估计程序的性能，作为算法分析的基本指标之一，但是平均情况和实际情况仍然会有相差很大的时候，这时我们便可以使用随机法来尽量模拟现实中的情况，这样可以得到在严格的概率意义上的预测运行时间。另外，对于一个经典算法，我们没有必要再去对该算法进行改进，研究它的上界和下界，只需要了解该算法的特性，然后在合适的时候使用它。

最后，当一个程序变快和变慢，让计算机反映出来的时间差几乎不会让人产生感觉的时候，我们也没有必要去改进这个算法，例如程序进行1000次循环花费0.001秒，改进后为0.1秒，在实际应用中通常也只需要几千次循环，此时我们就没有必要去花时间来研究这个算法了，只要该算法能正确完成任务即可。