Java 实现单向链表

概念

链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而顺序表相应的时间复杂度分别是O(logn)和O(1)。
使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。
在计算机科学中，链表作为一种基础的数据结构可以用来生成其它类型的数据结构。链表通常由一连串节点组成，每个节点包含任意的实例数据（data fields）和一或两个用来指向上一个/或下一个节点的位置的链接（”links”）。链表最明显的好处就是，常规数组排列关联项目的方式可能不同于这些数据项目在记忆体或磁盘上顺序，数据的访问往往要在不同的排列顺序中转换。而链表是一种自我指示数据类型，因为它包含指向另一个相同类型的数据的指针（链接）。链表允许插入和移除表上任意位置上的节点，但是不允许随机存取。链表有很多种不同的类型：单向链表，双向链表以及循环链表。

实现

public class LinkList {
    public static class Node {  //static main里可以直接用
        public int data;
        public Node next;

        public Node(int data) {
            this.data = data;
        }
        //显示此节点
        public void display() {
            System. out.print( data + " ");
        }
    }

    public Node first; // 定义一个头结点
    private int pos = 0;// 节点的位置

    public LinkList() {
        this. first = null;
    }

    // 插入一个头节点
    public void addFirstNode( int data) {
        Node node = new Node(data);
        node. next = first;
        first = node;
    }

    // 删除一个头结点,并返回头结点
    public Node deleteFirstNode() {
        Node tempNode = first;
        first = tempNode. next;
        return tempNode;
    }

    // 在任意位置插入节点 在index的后面插入
    public void add(int index, int data) {
        Node node = new Node(data);
        Node current = first;
        Node previous = first;
        while ( pos != index) {
            previous = current;
            current = current. next;
            pos++;
        }
        node. next = current;
        previous. next = node;
        pos = 0;
    }

    // 删除任意位置的节点
    public Node deleteByPos( int index) {
        Node current = first;
        Node previous = first;
        while ( pos != index) {
            pos++;
            previous = current;
            current = current. next;
        }
        if(current == first) {
            first = first. next;
        } else {
            pos = 0;
            previous. next = current. next;
        }
        return current;
    }

    // 根据节点的data删除节点(仅仅删除第一个)
    public Node deleteByData( int data) {
        Node current = first;
        Node previous = first; //记住上一个节点
        while (current. data != data) {
            if (current. next == null) {
                return null;
            }
            previous = current;
            current = current. next;
        }
        if(current == first) {
            first = first. next;
        } else {
            previous. next = current. next;
        }
        return current;
    }

    // 显示出所有的节点信息
    public void displayAllNodes() {
        Node current = first;
        while (current != null) {
            current.display();
            current = current. next;
        }
        System. out.println();
    }

    // 根据位置查找节点信息
    public Node findByPos( int index) {
        Node current = first;
        if ( pos != index) {
            current = current. next;
            pos++;
        }
        return current;
    }

    // 根据数据查找节点信息
    public Node findByData( int data) {
        Node current = first;
        while (current. data != data) {
            if (current. next == null)
                return null;
            current = current. next;
        }
        return current;
    }

    public static void main(String[] args) {
        LinkList linkList = new LinkList();
        linkList.addFirstNode(20);
        linkList.addFirstNode(21);
        linkList.addFirstNode(19);
        //19,21,20
        linkList.add(1, 22); //19,22,21,20
        linkList.add(2, 23); //19,22,23,21,20
        linkList.add(3, 99); //19,22,23,99,21,20
        linkList.displayAllNodes();
//        Node node = linkList.deleteFirstNode();
//        System.out.println("node : " + node.data);
//        linkList.displayAllNodes();
//        node = linkList.deleteByPos(2);
//        System.out.println("node : " + node.data);
//        linkList.displayAllNodes();
//        linkList.deleteFirstNode();
        Node node = linkList.deleteByData(19);
//        Node node = linkList.deleteByPos(0);
        System. out.println( "node : " + node. data);
        linkList.displayAllNodes();
        Node node1 = linkList.findByPos(0);
        System. out.println( "node1: " + node1. data);
        Node node2 = linkList.findByData(22);
        System. out.println( "node2: " + node2. data);
    }


}

ArrayList

import java.util.ArrayList;  
import java.util.Iterator;  
public class SimpleTest {  


 public static void main(String []args){  

  ArrayList list1 = new ArrayList();    
  list1.add("one");  
  list1.add("two");  
  list1.add("three");  
  list1.add("four");  
  list1.add("five");  
  list1.add(0,"zero");    
  System.out.println("<--list1中共有>" + list1.size()+ "个元素");    
  System.out.println("<--list1中的内容:" + list1 + "-->");  

  ArrayList list2 = new ArrayList();  
  list2.add("Begin");  
  list2.addAll(list1);  
  list2.add("End");  
  System.out.println("<--list2中共有>" + list2.size()+ "个元素");    
  System.out.println("<--list2中的内容:" + list2 + "-->");  

  ArrayList list3 =  new ArrayList();  
  list3.removeAll(list1);  
  System.out.println("<--list3中是否存在one: "+ (list3.contains("one")? "是":"否")+ "-->");  

  list3.add(0,"same element");  
  list3.add(1,"same element");  
  System.out.println("<--list3中共有>" + list3.size()+ "个元素");    
  System.out.println("<--list3中的内容:" + list3 + "-->");  
  System.out.println("<--list3中第一次出现same element的索引是" + list3.indexOf("same element") + "-->");  
  System.out.println("<--list3中最后一次出现same element的索引是" + list3.lastIndexOf("same element") + "-->");  


  System.out.println("<--使用Iterator接口访问list3->");  
  Iterator it = list3.iterator();  
  while(it.hasNext()){  
   String str = (String)it.next();  
   System.out.println("<--list3中的元素:" + list3 + "-->");  
  }  

  System.out.println("<--将list3中的same element修改为another element-->");  
  list3.set(0,"another element");  
  list3.set(1,"another element");  
     System.out.println("<--将list3转为数组-->");  
    // Object []  array =(Object[]) list3.toArray(new   Object[list3.size()] );  
     Object [] array = list3.toArray();  
     for(int i = 0; i < array.length ; i ++){  
      String str = (String)array[i];  
      System.out.println("array[" + i + "] = "+ str);        
     }       

     System.out.println("<---清空list3->");  
     list3.clear();  
     System.out.println("<--list3中是否为空: " + (list3.isEmpty()?"是":"否") + "-->");  
     System.out.println("<--list3中共有>" + list3.size()+ "个元素");   

  //System.out.println("hello world!");  
 }  
} 

参考：
http://blog.csdn.net/tayanxunhua/article/details/11100097/
http://blog.csdn.net/bitcarmanlee/article/details/52155181
http://jingyan.baidu.com/article/5bbb5a1b1f4c7613eba1790d.html