数据结构和算法学习（5）-链表

链表是继数组后第二种应用最广泛的的通用存储结构

数组作为存储结构有一定的缺陷，如：无序数组中搜索效率底下、有序数组中插入效率底下，而无论哪种数组中的删除效率都很低，并且数组创建后大小不可改变

链表的机制灵活，用途广泛，有助于解决上面的一些问题，他可以取代数组作为其他存储结构的基础，如栈、队列等。

除非需要频繁的通过下标随机访问个个数据，否则大多数应用数组的地方均可以用链表代替。

链结点（Link）

链表中每个数据项都被包含在链结点中，一个链结点是某个类的对象。因为一个链表中有许多类似的节点，所以有必要用一个不同于链表的类来表达链结点。

每个链接点对象中都包含对下一个链结点的引用的字段。但是链表本身的对象中有一个字段只想对第一个链接点的引用。

单链表

此处所涉及的单链表实际上是单向不循环链表，现实生活中的例子可以参照分级代理商来理解，假设每一级仅存在一个代理商，每一级代理商仅知道自己下一级代理商的联系方式，也就是说一级代理商想要找到三级代理商就只能联系二级代理商，并由二级代理商去联系三级代理商。

链表的操作无外乎增删改查，如下引用了一种简单的单链表实现

代码实现

首先建立实体类

public class Person {
    String name;
    int age;
    int personNo;
    
    public Person(String name, int age, int personNo) {
        this.name = name;
        this.age = age;
        this.personNo = personNo;
    }

    public String getName(){
        return this.name;
    }
    
    public int getAge(){
        return this.age;
    }
    
    public int getPersonNo(){
        return this.personNo;
    }
    
    public String toString(){
        return "姓名：" + this.name + "\t年龄：" + this.age +"\t编号" + this.personNo;
    }
}

然后建立链结点类将实体类包裹，并写入一个重要属性，即对表示对下一个节点的引用

public class PersonChainNode {
    Person person;
    PersonChainNode nextNode;

    public Person getPerson(){
        return this.person;
    }
    
    public PersonChainNode getNextEntity(){
        return this.nextNode;
    }
    
    public PersonChainNode (Person p,PersonChainNode ep){
        this.person = p;
        this.nextNode = ep;
    }
    
    public PersonChainNode (Person p){
        this.person = p;
    }
}

最后编写链表类，链表类中只包含对链表头中链结点的引用

class PersonChain {
    private PersonChainNode head;
    private int size;
    private int modCount;

    public int getSize() {
        return this.size;
    }

    public void addNode(Person p) {
        if (!contains(p.personNo)) {
            if (head != null) {
                head = new PersonChainNode((myChain.Person) p, head);
                size++;
                modCount++;
            } else {
                head = new PersonChainNode((myChain.Person) p, null);
                size++;
                modCount++;
            }
        }
    }
    public void deleteNode(int personNo) {
        if (size == 0) {
            return;
        }
        if (size == 1) { 
            if (head.person.personNo == personNo) {
                head = null;
                size = 0;
            }
            return;
        }
        if (!contains(personNo)) {
            return;
        }
        int index = 0;
        for (PersonChainNode p = head; p != null; p = p.nextNode) {
            if (!(p.person.personNo == personNo)) {
                index++;
            } else {
                break;
            }
        }
        if (index == 0) {
            head = new PersonChainNode(head.nextNode.person,
                    head.nextNode.nextNode);
            size--;
            modCount++;
            return;
        }
        int count = 0;
        for (PersonChainNode p = head; p != null; p = p.nextNode) {
            if (count == index - 1) {
                if (index == size - 1) {
                    p.nextNode = null;
                } else {
                    p.nextNode = p.nextNode.nextNode;
                }
                size--;
                modCount++;
                return;
            }
            count++;
        }
    }
    public Person searchNode(int personNo) {
        Person p = null;
        for (PersonChainNode pcn = head; pcn != null; pcn = pcn.nextNode) {
            if (pcn.person.personNo == personNo) {
                p = pcn.person;
            }
        }
        return p;
    }
    public void editNode(int personNo, Object value) {
        Person target = searchNode(personNo);
        if (target == null) {
            return;
        }
        if (value == null) {
            return;
        }
        if (value.getClass() == java.lang.String.class) {
            target.name = value.toString();
            return;
        }
        try {
            target.age = Integer.parseInt(value.toString());
            return;
        } catch (Exception ex) {
            return;
        }
    }
    public void printNode(int personNo) {
        Person target = searchNode(personNo);
        if (target == null) {
            return;
        }
        System.out.println(target.toString());
    }
    public boolean contains(int personNo) {
        if (size != 0) {
            for (PersonChainNode pcn = head; pcn != null; pcn = pcn.nextNode) {
                if (pcn.person.personNo == personNo) {
                    return true;
                }
            }
        }
        return false;
    }
    public void sort() {
        boolean jx = true; 
        for (PersonChainNode pcn = head; pcn != null && jx; pcn = pcn.nextNode) {
            jx = false;
            for (PersonChainNode pc = head; pc != null && pc.nextNode != null; pc = pc.nextNode) {
                if (pc.person.personNo > pc.nextNode.person.personNo) {
                    Person temp = pc.person;
                    pc.person = pc.nextNode.person;
                    pc.nextNode.person = temp;
                    jx = true;
                }
            }
        }
    }
    public void printAll() {
        if (size != 0) {
            for (PersonChainNode pcn = head; pcn != null; pcn = pcn.nextNode) {
                System.out.println(pcn.person.toString());
            }
        }
    }
}

双端链表

双端链表与传统链表非常相似，不同之处在于新增了对最后一个链结点的引用。

对最后一个连接点的引用允许在表尾直接插入一个链结点。

普通的插入方式是遍历整个链表到表尾再插入，而双端链表的操作效率则会大大提升。

最后，双端链表不同于双向链表。

效率

在表头插入和删除的速度很快，仅需要改变一两个引用值；而总的来讲，查找删除和在指定链结点后插入都需要搜索平均链表中的一半链结点。所以时间复杂度为

O(1)：表头的插入和删除

O(N)：平均时间

链表比数组优越的一个重要方面就在于链表不限制大小，也就是想要多少内存就多少内存，而且相对于数组来说，虽然在数组中执行插入删除也需要O(N)次比较，但是由于链表不需要移动，所以增加的效率也是明显要高于数组的

有序链表

有序链表顾名思义是在链表内部的数据有事有序的，有序链表的删除常常只操作在于链表头部的练级点，不过也可以在整个链表中搜索特定的链结点

相比于有序数组而言，有序链表有着优于有序数组的插入速度，而且在可扩展内存方面也是优于有序数组的地方

有序链表也可以实现优先级队列，但是堆会是更好的解决方案

效率

有序链表插入和删除某一项最多需要O(N)次比较（N/2）故时间复杂度为：

O(N/2)

双向链表

双向链表提供了双向遍历的能力，即允许向前遍历，也允许向后遍历

主要在于双向链表的每一个链结点都存在两个指向其他链结点的引用，第一个指向下一个链结点，第二个指向前一个链结点

双向链表不必是双端链表

缺点

由于双向链表的每一个链结点中存在着两个对于其他连接点的引用，所以每次操作是要处理四个链结点的引用，所以相应会增加操作

链结点占用的空间也就大了一些

基于双向链表的双端队列

组成双端队列的双向链表可以提供从任何一段进行插入和删除的能力

迭代器

链表本身并没有提供遍历操作，这样就给许多基于查找的操作带来了不便

设想基于数组的遍历是通过下标完成的，所以自然想到为链表添加一个字段来达到遍历的功能

然而可能用户会同时使用多个引用，基于面向对象的考虑，将迭代器做成一个类是比较合适的，链表内部应当包含获取迭代器的方法

不只是进行对链表的遍历，对链表的其他操作也可以考虑通过迭代器来进行，然而如果进行其他操作的话例如对当前链结点的前后链结点的引用进行修改时，就需要传递它们的引用，并将其存储在迭代器的字段中，也就是在创建构造器的时候应当使用带参数的构造函数进行创建实例，传递的参数是当前链表的引用

一些列出了迭代器中可能包含的方法

-reset() 把迭代器设在表头

-nextLink() 把迭代器移动到下一个链结点

-getCurrent() 返回迭代器指向的链结点

-atEnd() 判断迭代器是否到达表尾

-insertBefore() 在迭代器前面插入新的链结点

-insertAfter() 在迭代器后面插入新的链结点

-deleteCurrent() 删除迭代器所指链结点