单向链表

链表结构

链式存储结构式基于指针实现的。我们把一个数据元素和一个指针称为结点。

链式存储结构式用户指针把相互直接关联的结点(即直接前驱结点或直接后驱结点)链接起来。链式存储结构的线性表称为链表。

链表类型

根据链表的构成方式的不同可以分为：

1.单向链表

2.单向循环链表

3.双向循环链表

单向链表

单链表式构成链表的每个结点只有一个指向直接后继点的指针。

单链表的表示方法：

单链表中每个结点的结构：

单链表结构

单链表有带头结点结构和不带头系欸但结构两种。我们吧指向单聊表的指针称为单链表的头指针。头指针所指的不存放数据元素的第一个结点称作头结点。存放第一个数据元素的结点称作第一个数据元素结点，或称首元结点。

结点类

单链表是由一个一个结点组成的，因此，要设计单链表类，必须先设计结点类。节点类的成员变量有两个：一个是数据元素，另一个是表示下一个结点的对象引用(即指针)。

设计操作:

1.头结点的初始化

2.非头节点的构造

3.获取该结点指向的下个结点

4.设置该结点指向的下个结点

5.设置该结点的数据

6.获取该结点的数据

// 结点类
public class Node {

    // 数据域
    Object element;
    // 指针域
    Node next;

    // 头结点的构造方法
    public Node (Node nextval) {
        this.next = nextval;
    }

    // 非头结点的构造方法
    public Node(Object obj, Node nextval) {
        this.element = obj;
        this.next = nextval;
    }

    // 获得当前结点的后继结点
    public Node getNext() {
        return this.next;
    }

    // 获取当前的数据域的值
    public Object getElement() {
        return this.element;
    }

    // 设置当前结点的指针域
    public void setNext(Node nextval) {
        this.next = nextval;
    }

    // 设置当前结点的数据域
    public void setElement(Object obj) {
        this.element = obj;
    }

    @Override
    public String toString() {
        return "Node{" +
                "element=" + element +
                ", next=" + next +
                '}';
    }
}

单链表类

单链表类的成员变量至少要有两个：一个是头指针,另一个是单链表中的数据元素个数。但是,如果再增加一个表示单链表当前结点位置的成员变量,则有些成员函数的设计将更加方便。

// 线性表接口
public interface List {

    // 获得线性表长度
    public int size();

    // 判断线性表是否为空
    public boolean isEmpty();

    // 指定索引插入元素
    public void insertIndex(int index, Object obj) throws Exception;

    // 不指定索引插入元素
    public void insert(Object object) throws Exception;

    // 指定删除元素
    public void delete(int index) throws Exception;

    // 获取指定位置的元素
    public Object get(int index) throws Exception;
}

// 单向链表类
public class LinkList implements List {

    // 头指针
    Node head;
    // 当前结点对象
    Node current;
    // 结点的个数
    int size;

    // 初始化一个空链表
    public LinkList() {
        // 初始化头节点,让头指针指向头结点。并且让当前结点对象等于结点。
        head = current = new Node(null);
        // 单向链表,初始长度为零
        this.size  = 0;
    }

    // 定位函数,实现当前操作对象的前一个结点,也就是让当前结点对象定位到要操作结点的前一个结点
    public void index(int index) throws Exception{
        // -1 为头节点位置
        if (index < -1 || index > size - 1) {
            throw new Exception("参数错误!");
        }
        // 说明在头节点之后进行操作
        if (index == -1)
            return;

        current = head.next;
        int j = 0;
        while (current != null && j < index) {
            current = current.next;
            j++;
        }
    }

    @Override
    public int size() {
        return this.size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public void insertIndex(int index, Object obj) throws Exception {
        if (index < 0 || index > size) {
            throw new Exception("参数错误! ");
        }
        // 定位到要错做结点的前一个结点对象 current。
        index(index-1);
        // 将新添加的值结点设置到当前结点对象的后面,并将current对应的下个结点调整到添加的值结点的后面
        current.setNext(new Node(obj, current.next));
        size++;
    }

    @Override
    public void insert(Object object) throws Exception {
        if (object == null) {
            throw new Exception("参数为空,执行失败");
        }
        index(size -1);
        size++;
        current.setNext(new Node(object, null));
    }

    @Override
    public void delete(int index) throws Exception {
        // 判断链表是否为空
        if (isEmpty()) {
            throw new Exception("链表为空.无法删除!");
        }
        if (index < 0 || index > size) {
            throw new Exception("参数错误! ");
        }
        // 定位到要操作结点的前一个结点对象
        index(index - 1);
        // 修改前一个结点对象的指针域,指向下下个
        current.setNext(current.next.next);
        size--;
    }

    @Override
    public Object get(int index) throws Exception {
        if (index < 0 || index > size) {
            throw new Exception("参数错误! ");
        }
        index(index);

        return current.getElement();
    }
}

Test

    public static void main(String[] args) throws Exception {
        LinkList linkList = new LinkList();
        for (int i = 0; i < 10; i++) {
            int temp = ((int) (Math.random()*100))%100;
            linkList.insertIndex(i, temp);
            System.out.print(temp + "   ");
        }

        linkList.delete(4);
        System.out.println("\n=======删除第五个元素之后=======");
        for (int i = 0; i < linkList.size; i++) {
            System.out.println(linkList.get(i) + "   ");
        }
    }

    结果:
    60   91   20   83   53   87   86   99   19   90   
    =======删除第五个元素之后=======
    87   
    91   
    20   
    83   
    87   
    86   
    99   
    19   
    90   

顺序表和单链表的比较

1.顺序表的主要优点是支持随机读取,以及内存空间利用效率高；顺序表的主要缺陷是需要预先给出数组的最大数据元素个数，而这通常很难准确做到。当实际的数据元素个数超过预先给出的个数，会发生异常。另外，顺序表插入和删除操作时需要移动较多的数据元素。

2.和顺序表相比，单链表的主要优点是不需要预先给出数据元素的最大个数。另外，单链表插入和删除操作时不需要移动数据元素。

3.单链表的主要缺点时每个结点中要有一个指针，因此单链表的空间利率略低于顺序表的。另外，单链表不支持随机读取，单链表取出书元素操作的时间复杂度为O(n);而顺序表支持随机读取，顺序表取数据元素操作的时间复杂度为O(1)。