数据结构之单链表（基于Java实现）

链表：在计算机中用一组任意的存储单元存储线性表的数据元素称为链式存储结构，这组存储结构可以是连续的，也可以是不连续的，因此在存储数据元素时可以动态分配内存。

注：在java中没有指针的概念，可以理解为对象的引用。

单链表的特点是链表的方向是单向的，对链表的访问要通过顺序读取，从头部开始。单链表是由一个个节点（Node）组装起来的，其中每个节点都由成员变量指向下一个节点。

特点概述：

　　每个节点由数据域和指针域组成

　　比顺序结构存储密度小。链式存储结构中每个节点都由数据域和指针域两部分组成，相比顺序结构增加了存储空间

　　逻辑上相邻的两个节点物理位置不必相邻

　　插入，删除灵活

　　查找节点时链式存储结构要比顺序结构慢

Java中链表的定义如下：

class Node<T>{

　　E data;

　　Node<E> next;

}

基于Java，来探究一下链表的原理：

首先，写一段简单的代码

public class Node <T>{
    private T v;
    Node<T> next;
    public static void main(String[] args){
        Node node3 = new Node();
        node3.v = "a";
        Node node2 = new Node();
        node2.v = "b";
        node2.next = node3;
        Node node1 = new Node();
        node1.v = "c";
        node1.next = node2;
        System.out.println(node1);
    }
}

运行截图：

上述代码中，我们使node1的后继为node2，node2的后继为node3，更直观一点

下面，来看一下单链表的具体结构的实现：

public class SinglyLinkedList<E> {
    private int size = 0;
    private Node<E> first;
    private Node<E> last;
    public SinglyLinkedList(){
    }
    private static class Node<E>{
        E data;
        Node<E> next;
        Node(E element,Node<E> next){
            this.data = element;
            this.next = next;
        }

    }
    public int size(){
        return size;
    }
    public boolean isEmpty(){
        return size() == 0;
    }
    public boolean contains(Object o){
        if(o == null){
            for(Node<E> x = first;x!=null;x = x.next){
                if(x.data == null){
                    return true;
                }
            }
        }else{
            for(Node<E> x = first;x!=null;x = x.next){
                if(o.equals(x.data)){
                    return true;
                }
            }
        }
        return false;
    }
    public boolean add(E e){
        final Node<E> newNode = new Node<>(e,null);
        final Node<E> l = last;
        last = newNode;
        if(l == null){
            first = newNode;
            last = newNode;
        }else{
            l.next = newNode;
        }
        size++;
        return true;

    }
    public E get(int index){
        if(index < 0 || index > size - 1){
            throw new IndexOutOfBoundsException("index " + index + "out of bounds");
        }
        Node<E> x = first;
        for(int i = 0;i < index;i++){
            x = x.next;
        }
        return x.data;
    }
    public E set(int index,E element){
        if(index < 0 || index > size - 1){
            throw new IndexOutOfBoundsException("index " + index + "out of bounds");
        }
        Node<E> x = first;
        for(int i = 0; i< index; i++){
            x = x.next;
        }
        E oldValue = x.data;
        x.data = element;
        return oldValue;
    }
    public E remove(int index){
        if(index < 0 || index > size - 1){
            throw new IndexOutOfBoundsException("index " + index + "out of bounds");
        }
        Node<E> x,p;
        if(index == 0){
            x = first;
            first = first.next;
        }else{
            p = first;
            for(int i = 0;i < index-1;i++){
                p = p.next;
            }
            x = p.next;
            p.next = x.next;

        }
        final E element = x.data;
        x.data = null;
        size--;
        return element;
    }
    public void addFirst(E e){
        final Node<E> f = first;
        final Node<E> newNode = new Node<>(e,null);
        first = newNode;
        if(f == null){
            last = newNode;
        }else{
            newNode.next = f;
        }
        size++;
    }
    public void addLast(E e){
        add(e);
    }
　　

}

public void addLast(E e){
        add(e);
    }
    public E removeFirst(){
        return remove(0);
    }
    public E removeLast(){
        return remove(size-1);
    }

方法说明：我们首先定义了链表的头节点和尾节点，为了方便我们后续的操作（比如判断链表是否为空等），然后定义链表的元素个数，这俩参考集合中.size（）方法，

然后声明一个无参构造器，用来实例化；接着，定义链表的结构，很显然，这是一个内部类；因为Java中没有指针的概念，在这里Node<E> next表示引用的概念（地址）；

一个单链表包含两部分，一部分数据域一部分指针域（个人叫法：引用域）；

第一个方法，用来返回单链表中的元素个数；第二个方法用来查看链表是否为空；第三个方法查看链表是否包含某元素o；然后依次是增加元素，修改元素，删除元素等；