数据结构之单链表

链表是一种数据结构，和数组同级。链表中的数据是以结点来表示的，每个结点构成：元素+指针 。元素就是存储数据单元，指针就是连接每个结点的地址数据。比如，java中我们经常使用的ArrayList，其实现原理是数组，而LinkedList的实现原理就是链表。链表在进行循环遍历时效率不高，但是在插入和删除是优势明显，下面对单链表做介绍

一、简介

以”结点的序列”表示线性表称为”线性链表(单链表)”。也就是说它实际上是由结点(Node)组成的，一个链表拥有不定数量的结点其数据在内存中存储是不连续的，它存储的数据分散在内存中，每个结点只能也只有它能知道下一个结点的存储位置。由N各节点（Node）组成单向链表，每一个Node记录本Node的数据及下一个Node的存储位置。向外暴露的只有一个头节点（Head），我们对链表的所有操作，都是直接或者间接地通过其头节点来进行的。 如图所示:

上图中最左侧的结点就是头结点，但是新添加的结点的顺序是从左到右的，添加的新结点会被作为新节点。最先添加的结点对下一个结点的引用可以为空。

二、链表的结点变量

上图中蓝色的部分就是结点的结构。
对象(data)：存放结点值的数据域。
引用(next)：存放结点的直接后继的地址(位置)的指针域(链域)。

三、链表的具体存储方式

1）用一组任意的存储单元来存放线性表的结点(这组存储单元既可以是连续的，也可以是不连续的),如下图所示。
2）链表中的结点逻辑次序和物理次序不一定相同。为了正确表示结点见的逻辑关系，在存储每个结点值的同事，还必须存储指示其后继结点的地址或位置信息(成为指针或链)。

下图简单的描述了单向链表存储情况。存储是分散的，每一个结点只要记录下一个结点就把所有数据串了起来，形成了一个单向的链表。

四、单链表的建立


单链表的建立有头插法、尾插法两种方法:

1、头插法：在头结点（头结点的数据域可以存放数据标题、表长等信息，也可以不存储任何信息，其指针域存储第一个结点的首地址）之后插入数据，其特点就是：读入的数据顺序与线性表的逻辑正好相反，如图所示。

注:  头插法建单链表是将链表右端看成固定的，链表不断向左延伸而得到的。头插法最先得到的是尾结点(链表的最右边)

从上图可以看出头插法就是从一个空表开始，重复读入数据，形成新结点，将读入数据存放到新结点的数据域中，然后将新结点插入到当前链表的表头结点之后。

算法实现如下:
Step1.定义一个链表的结点

package test;

/**
 * Created by DELL on 2017/11/24.
 * 链表结点的实现
 */
public class Node<T> {

    /**
     * 下一个结点
     */
    Node<T> next;
    /**
     * 结点存储的数据
     */
    T val;

    public Node(T val, Node<T> next) {
        this.next = next;
        this.val = val;
    }
}

Step2.定义一个单链表头插法的操作类

package test;

/**
 * Created by DELL on 2017/11/24.
 * 单链表的头插法操作类
 */
public class LinearList<T> {
    Node<T> head ; //链表的头结点
    Node<T> tail ; //链表的尾结点
    static int length;//定义链表长度

    public LinearList() {
        //空链表
        this.head = null;
        this.tail = null;
    }
    //头插法 链表 指针指向this.head
    void add(T val){
        this.head = new Node<T>(val,this.head);
        if(this.tail == null){
            //此时将尾结点固定,不断改变的是头结点
            this.tail = this.head;
        }
        //链表长度加1
        length ++ ;
    }

    public static void main(String[] args){
        LinearList<Integer> list = new LinearList<Integer>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        Node<Integer> head = list.head;
        while(head!=null){
            System.out.println(head.val);
            head = head.next;
        }
        System.out.println("链表的长度为:"+length);
    }

    /**
     * 读入的数据顺序与线性表的逻辑正好相反
     * 运行结果
     * 5
     * 4
     * 3
     * 2
     * 1
     * 链表的长度为:5
     * 
     */

}

2.尾插法:尾插法就是将链表的左端固定,链表不断向右延伸也就是说将每次插入的新结点放在链表的尾部，如图所示:

注:尾插法建立链表时，头指针固定不动， 故必须设立一个搜索指针，向链表右边延伸，则整个算法应设立三个链表指针，即头指针、搜索指针、申请单元指针。尾插法最先得到的是头结点

从上图可以看出，尾插法就是从一个空表开始，重复读入数据，生成新结点，将读入数据存放在新结点的数据域中，然后将新结点插入到当前链表的表尾上，直到读入结束标志为止。

算法实现
Step1.定义结点类

package test;

/**
 * Created by DELL on 2017/11/24.
 * 链表结点的实现
 */
public class Node<T> {

    /**
     * 下一个结点
     */
    Node<T> next;
    /**
     * 结点存储的数据
     */
    T val;

    public Node(T val, Node<T> next) {
        this.next = next;
        this.val = val;
    }
}

Step2.定义一个单链表的尾插法的操作类

package test;

/**
 * Created by DELL on 2017/11/25.
 */
public class TailLinerList<T> {
    Node<T> head ; //链表的头结点
    Node<T> tail; //链表的尾结点
    static int length;
    public TailLinerList() {
        //空链表
        this.tail = null;
        this.head = null;
    }
    public void tialInsert(T val){
        //判断是否有尾结点,如果没有尾结点则说明此时是一个空的链表
        if(this.tail == null){
            //定义一个结点
            this.tail = new Node<T>(val,null);
            //由于是插入第一个元素此时头结点和尾结点是同一个
            //此时将头结点固定,不断该改变的是尾结点
            this.head = this.tail;
        }else{
            //从插入第二个元素开始进入这部分
            //此时尾结点的next应该指向新结点
            this.tail.next = new Node<T>(val,null);
            //把链表的尾结点变成新插入进来的结点
            this.tail = this.tail.next;
        }
        //链表长度加1
        length++;
    }
    public static void  main(String[] args){
        TailLinerList<Integer> tailLinerList = new TailLinerList<Integer>();
        tailLinerList.tialInsert(6);
        tailLinerList.tialInsert(7);
        tailLinerList.tialInsert(8);
        tailLinerList.tialInsert(9);
        tailLinerList.tialInsert(10);
        Node<Integer> headList = tailLinerList.head;
        while(headList !=null ){
            System.out.println(headList.val);
            headList = headList.next;
        }
        System.out.println("链表的长度为:"+length);
    }
    /**
     * 读入的数据顺序与线性表的逻辑相同
     * 运行结果
     * 6
     * 7
     * 8
     * 9
     * 10
     * 链表的长度为:5
     */

}

综上所述：因为单链表的特殊结构,即只能从头向尾遍历,所以向头插时所用的语句会比向尾插少几个,向尾插时还要多一个指针指向尾结点,而用头插法时就不用,但用头插法时最先输入的数据会排在链表的最后,输出时即变成了输入时的逆序输出,看起来不如用尾插法那样和输入的顺序一样的形势更舒服些 。

五、链表中动态存储分配常用的标准函数
1)malloc(size)
在内存动态存储区申请一个长度为size字节的连续空间,但是需设立一申请单元指针，但malloc()函数得到的指针并不是指向结构体（是由一系列具有相同类型或不同类型的数据构成的数据集合）的指针，需使用强制类型转换，将其转换成结构体型指针。

2)calloc(n,size)
在内存的动态存储区申请n个长度为size字节的连续空间，函数返回值为分配空间的首地址。若此函数未被成功执行，函数返回值为0。

3)free(p)
释放由指针p所指向的存储单元，而存储单元的大小是最近一次调用malloc()或calloc()函数时所申请的存储空间。