链表

链表

链表(Linked List)

动态数组有个明显得缺点

• 可能造成内存空间的大量浪费

能否用到多少就申请多少内存？

• 链表可以办到这一点

链表是一种链式存储的线性表, 所有元素的内存地址不一定是连续的

链表(Linked List)接口设计

链表的大部分接口和动态数组是一致的

int size();//元素的数量
boolean isEmpty();//是否为空
boolean contains(E element);//是否包含某个元素
void add(E element);//添加元素到最后面
E get(int index);//返回index位置对应的元素
E set(int index, E element);//设置index位置的元素
void add(int index, E element);//往index位置添加元素
E remove(int index);//删除index位置对应的元素
int indexOf(E element);//查看元素的位置
void clear();//清除所有元素

由于链表的大部分接口和动态数组一致，我们抽取出一个共同的 List 接口

/**
 * list 接口供动态数组和链表实现
 * @param <E> 泛型
 */
public interface List<E> {
    // 表示元素不存在
    static final int ELEMENT_NOT_FOUND = -1;
    /**
     * 清除所有元素
     */
    void clear();

    /**
     * 元素的数量
     * @return
     */
    int size();

    /**
     * 是否为空
     * @return
     */
    boolean isEmpty();

    /**
     * 是否包含某个元素
     * @param element
     * @return
     */
    boolean contains(E element);

    /**
     * 添加元素到尾部
     * @param element
     */
    void add(E element);

    /**
     * 获取index位置的元素
     * @param index
     * @return
     */
    E get(int index);

    /**
     * 设置index位置的元素
     * @param index
     * @param element
     * @return 原来的元素ֵ
     */
    E set(int index, E element);

    /**
     * 在index位置插入一个元素
     * @param index
     * @param element
     */
    void add(int index, E element);

    /**
     * 删除index位置的元素
     * @param index
     * @return
     */
    E remove(int index);

    /**
     * 查看元素的索引
     * @param element
     * @return
     */
    int indexOf(E element);
}

再将一些通用的字段与方法放到一个抽象类中，无论是动态数组还是链表都只需要继承这个抽象类

/**
 * 动态数组和链表公共的方法 其他方法有各自的实现
 * @param <E> 泛型
 */
public abstract class AbstractList<E> implements List<E>{
    /**
     * 元素数量
     */
    protected int size;

    /**
     * 元素的数量
     * @return
     */
    public int size(){
        return size;
    }
    /**
     * 是否为空
     * @return
     */
    public boolean isEmpty(){
        return size == 0;
    }
    /**
     * 是否包含某个元素
     * @param element 元素
     * @return
     */
    public boolean contains(E element){
        return indexOf(element) != ELEMENT_NOT_FOUND;
    }
    /**
     * 添加元素到最后面
     * @param element
     */
    public void add(E element){
        add(size,element);
    }

    /**
     * 越界异常提示
     * @param index
     */
    protected void outOfBounds(int index){
        throw new IndexOutOfBoundsException("Index:"+index+", Size:"+size);
    }

    /**
     * 边界判断
     * @param index
     */
    protected void rangeCheck(int index){
        if (index < 0 || index >= size){
            this.outOfBounds(index);
        }
    }

    /**
     * 添加时边界判断
     * @param index
     */
    protected void rangeCheckForAdd(int index){
        if (index < 0 || index > size){
            this.outOfBounds(index);
        }
    }
}

创建 LinkedList 继承 AbstractList

• size属性记录存储数据的数量，创建first属性引用链表的第0个元素，来管理链表的数据
• 创建私有类Node，其中的element属性用于存储元素，next属性用于指向链表中的下一个结点

public class LinkedList<E> extends AbstractList<E>{
    /**
     * 元素所在的结点
     */
    private Node<E> first;

    /**
     * 内部类 结点
     * @param <E>
     */
    private static class Node<E>{
        E element;//元素
        Node<E> next;//下个元素的地址
        public Node(E element, Node<E> next) {
            this.element = element;
            this.next = next;
        }
    }
}

默认构造方法

链表的创建与动态数组不同，动态数组在构造时需要传入一个空间属性，来决定这个数组的容量。但链表元素是在添加时才创建的，内存地址不一定是连续的。所以链表不需要在单独设计构造方法，使用默认构造方法

清空元素 - clear()

将first指向null，释放链表所有node，同时size置为0

public class LinkedList<E> extends AbstractList<E>{
    ......
    
    /**
     * 清除所有元素
     */
    public void clear(){
        size = 0;
        first = null;
    }    
        
    ......
}

查找结点 - node(int index)

此时需要添加node()方法获取索引(index)位置对应的结点

public class LinkedList<E> extends AbstractList<E>{
    ......
    
     /**
     * 获取index位置对应的结点对象
     * @param index
     * @return
     */
    private Node<E> node(int index){
        rangeCheck(index);
        Node<E> node = first;
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        return node;
    }
        
    ......
}

添加元素 - add(int index, E element)

• 添加数据结点时，需要创建一个结点存储数据，并将该结点拼接到最后结点的后面，然后size加1
• 需要区分当前链表没有数据，新结点拼接到first和当前链表有数据，新结点拼接到最后的结点
• 添加元素尤其要注意 0 位置，给空链表添加first结点是个特殊情况

public class LinkedList<E> extends AbstractList<E>{
    ......
    
     /**
     * 返回index位置对应的元素
     * @param index
     * @return
     */
    public E get(int index){
        return node(index).element;
    }
    /**
     * 设置index位置的元素
     * @param index
     * @param element
     * @return
     */
    public E set(int index, E element){
        Node<E> node = node(index);
        E old = node.element;
        node.element = element;
        return old;
    }

    /**
     * 往index位置添加元素
     * @param index
     * @param element
     */
    public void add(int index, E element){
        //边界判断
        rangeCheckForAdd(index);
        if (index == 0){// 给空链表添加第一个元素的情况
            //创建新结点，first结点指向这个新结点
            first = new Node<>(element,first);
        }else {
            //index上一个结点
            Node<E> prev = node(index - 1);
            //创建新结点，prev结点指向这个新结点
            prev.next = new Node<>(element, prev.next);
        }
        size++;
    }
        
    ......
}

删除元素 - remove(int index)

• 首先找到删除结点的前一个结点(prev)，然后通过变更(prev)结点next指针指向删除结点的下一个结点，然后size减1
• 需要判断是否删除的第0个元素，如果是，则使用first结点指向第1个结点

public class LinkedList<E> extends AbstractList<E>{
    ......
    
     /**
     * 删除index位置对应的元素
     * @param index
     * @return
     */
    public E remove(int index){
        //边界判断
        rangeCheck(index);
        //记录结点
        Node<E> node = first;
        if (index == 0){ // 删除第一个元素是特殊情况
            first = first.next;
        }else {
            //index上一个结点
            Node<E> prev = node(index - 1);
            //记录删除的结点
            node = prev.next;
            //node结点下一个结点，prev结点指向这个结点
            prev.next = node.next;
        }
        size --;
        return node.element;
    }
        
    ......
}

查找元素位置 - indexOf(E element)

• 查找指定元素的索引，需要遍历所有结点，找到结点对应的元素与执行元素相等

  如果需要支持结点element为null，则需要分情况处理

public class LinkedList<E> extends AbstractList<E>{
    ......
    
     /**
     * 查看元素的位置
     * @param element
     * @return
     */
    public int indexOf(E element){
        // 取出头结点
        Node<E> node = first;
        if(element ==null){// 当element为null时的处理
            // 遍历结点, 找到存储为null的结点, 返回索引
            for (int i = 0; i < size; i++) {
                if (node.element == null) return i;
                node = node.next;
            }
        }else {
            // 遍历结点, 找到存储的元素与指定元素相等的结点, 返回索引
            for (int i = 0; i < size; i++) {
                if (element.equals(node.element)) return i;
                node = node.next;
            }
        }

        return ELEMENT_NOT_FOUND;
    }
        
    ......
}

打印元素 - toString()

• 重写toString方法
• 在toString 方法中将元素拼接成字符串
• 字符串拼接建议使用StringBuilder

public class LinkedList<E> extends AbstractList<E>{
    ......
    
     /**
     * 打印
     * @return
     */
    @Override
    public String toString() {
        //Size = ? , [1, 2, 3]
        StringBuilder string = new StringBuilder();
        string.append("size=").append(size).append(", [");
        Node<E> node = first;
        for (int i = 0; i < size; i++) {
            if (i != 0){
                string.append(", ");
            }
            string.append(node.element);
            node = node.next;
        }
        string.append("]");
        return string.toString();
    }
        
    ......
}

完整代码 --- 单向链表

/**
 * 单链表的实现
 * @param <E> 泛型
 */
public class LinkedList<E> extends AbstractList<E>{
    /**
     * 元素所在的结点
     */
    private Node<E> first;

    /**
     * 内部类 结点
     * @param <E>
     */
    private static class Node<E>{
        E element;//元素
        Node<E> next;//下个元素的地址
        public Node(E element, Node<E> next) {
            this.element = element;
            this.next = next;
        }
    }

    /**
     * 返回index位置对应的元素
     * @param index
     * @return
     */
    public E get(int index){
        return node(index).element;
    }
    /**
     * 设置index位置的元素
     * @param index
     * @param element
     * @return
     */
    public E set(int index, E element){
        Node<E> node = node(index);
        E old = node.element;
        node.element = element;
        return old;
    }

    /**
     * 往index位置添加元素
     * @param index
     * @param element
     */
    public void add(int index, E element){
        //边界判断
        rangeCheckForAdd(index);
        if (index == 0){// 给空链表添加第一个元素的情况
            //创建新结点，first结点指向这个新结点
            first = new Node<>(element,first);
        }else {
            //index上一个结点
            Node<E> prev = node(index - 1);
            //创建新结点，prev结点指向这个新结点
            prev.next = new Node<>(element, prev.next);
        }
        size++;
    }
    /**
     * 删除index位置对应的元素
     * @param index
     * @return
     */
    public E remove(int index){
        //边界判断
        rangeCheck(index);
        //记录结点
        Node<E> node = first;
        if (index == 0){ // 删除第一个元素是特殊情况
            first = first.next;
        }else {
            //index上一个结点
            Node<E> prev = node(index - 1);
            //记录删除的结点
            node = prev.next;
            //node结点下一个结点，prev结点指向这个结点
            prev.next = node.next;
        }
        size --;
        return node.element;
    }

    /**
     * 查看元素的位置
     * @param element
     * @return
     */
    public int indexOf(E element){
        // 取出头结点
        Node<E> node = first;
        if(element ==null){// 当element为null时的处理
            // 遍历结点, 找到存储为null的结点, 返回索引
            for (int i = 0; i < size; i++) {
                if (node.element == null) return i;
                node = node.next;
            }
        }else {
            // 遍历结点, 找到存储的元素与指定元素相等的结点, 返回索引
            for (int i = 0; i < size; i++) {
                if (element.equals(node.element)) return i;
                node = node.next;
            }
        }

        return ELEMENT_NOT_FOUND;
    }
    /**
     * 清除所有元素
     */
    public void clear(){
        size = 0;
        first = null;
    }

    /**
     * 获取index位置对应的结点对象
     * @param index
     * @return
     */
    private Node<E> node(int index){
        rangeCheck(index);
        Node<E> node = first;
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        return node;
    }

    /**
     * 打印
     * @return
     */
    @Override
    public String toString() {
        //Size = ? , [1, 2, 3]
        StringBuilder string = new StringBuilder();
        string.append("size=").append(size).append(", [");
        Node<E> node = first;
        for (int i = 0; i < size; i++) {
            if (i != 0){
                string.append(", ");
            }
            string.append(node.element);
            node = node.next;
        }
        string.append("]");
        return string.toString();
    }


}

虚拟头结点 --- 存在内存问题

有时候为了让代码更加精简，统一所有结点的处理逻辑，可以在最前面增加一个虚拟头结点（不存储数据）

带虚拟头结点的单向链表与普通单向链表代码类似：但是 add、remove略有不同；

/**
 * 增加一个虚拟头结点
 * @param <E> 泛型
 */
public class VirtualHeadLinkedList<E> extends AbstractList<E>{
    /**
     * 元素所在的结点
     */
    private Node<E> first;

    /**
     * 内部类 结点
     * @param <E>
     */
    private static class Node<E>{
        E element;//元素
        Node<E> next;//下个元素的地址
        public Node(E element, Node<E> next) {
            this.element = element;
            this.next = next;
        }
    }

    /**
     * 构造函数 创建一个空结点 --- 增加
     */
    public VirtualHeadLinkedList() {
        this.first = new Node<>(null,null);
    }

    /**
     * 返回index位置对应的元素
     * @param index
     * @return
     */
    public E get(int index){
        return node(index).element;
    }
    /**
     * 设置index位置的元素
     * @param index
     * @param element
     * @return
     */
    public E set(int index, E element){
        Node<E> node = node(index);
        E old = node.element;
        node.element = element;
        return old;
    }

    /**
     * 往index位置添加元素 --- 修改
     * @param index
     * @param element
     */
    public void add(int index, E element){
        //边界判断
        rangeCheckForAdd(index);
        Node<E> prev = index ==0 ? first : node(index - 1);
        prev.next = new Node<>(element, prev.next);
        size++;
    }
    /**
     * 删除index位置对应的元素 --- 修改
     * @param index
     * @return
     */
    public E remove(int index){
        //边界判断
        rangeCheck(index);
        Node<E> prev = index == 0 ? first : node(index - 1);
        Node<E> node = prev.next;
        prev.next = node.next;
        size --;
        return node.element;
    }

    /**
     * 查看元素的位置
     * @param element
     * @return
     */
    public int indexOf(E element){
        // 取出头结点
        Node<E> node = first;
        if(element ==null){// 当element为null时的处理
            // 遍历结点, 找到存储为null的结点, 返回索引
            for (int i = 0; i < size; i++) {
                if (node.element == null) return i;
                node = node.next;
            }
        }else {
            // 遍历结点, 找到存储的元素与指定元素相等的结点, 返回索引
            for (int i = 0; i < size; i++) {
                if (element.equals(node.element)) return i;
                node = node.next;
            }
        }

        return ELEMENT_NOT_FOUND;
    }
    /**
     * 清除所有元素
     */
    public void clear(){
        size = 0;
        first = null;
    }

    /**
     * 获取index位置对应的结点对象 --- 修改
     * @param index
     * @return
     */
    private Node<E> node(int index){
        rangeCheck(index);
        //first的下一个结点
        Node<E> node = first.next;
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        return node;
    }

    /**
     * 打印 --- 修改
     * @return
     */
    @Override
    public String toString() {
        //Size = ? , [1, 2, 3]
        StringBuilder string = new StringBuilder();
        string.append("size=").append(size).append(", [");
        Node<E> node = first.next;
        for (int i = 0; i < size; i++) {
            if (i != 0){
                string.append(", ");
            }
            string.append(node.element);
            node = node.next;
        }
        string.append("]");
        return string.toString();
    }

}

动态数组、链表复杂度分析

数组的随机访问速度非常快：elements[n]的效率与 n 是多少无关；

双向链表

• 单向链表只能通过Node中next属性从头遍历链表，完成搜索
• 双向链表中的Node增加prev属性，指向该结点上一个结点
• 双向链表查找元素可以从first或last两个方向开始查找

因此双向链表可以提升链表的综合性能

双向链表只有一个结点(元素)

双向链表接口设计

相较于单向链表，双向链表需要重写查找结点、插入结点、删除结点、清空结点四个方法

• 新增一个last元素，最后一个元素
• 私有结点Node 中的prev 元素用于指向链表中的上一个结点

public class LinkedList<E> extends AbstractList<E> {
    /**
     * 元素所在的结点
     */
    private Node<E> first;
     //增加last结点
    private Node<E> last;

    /**
     * 内部类 结点
     * @param <E>
     */
    private static class Node<E>{
        E element;//元素
        Node<E> prev;//增加上一个元素地址
        Node<E> next;//下个元素的地址
        public Node(E element, Node<E> prev,Node<E> next) {
            this.element = element;
            this.prev = prev;
            this.next = next;
        }
    }
}

查找结点 - node(int index)

通过判断查找的节点在链表的前半段或后半段，选择first结点从前往后遍历或last结点从后往前遍历

public class LinkedList<E> extends AbstractList<E>{
    ......
    
    /**
     * 获取index位置对应的节点对象
     * @param index
     * @return
     */
    private Node<E> node(int index){
        rangeCheck(index);
        //往后
        if (index < (size >> 1)){
            Node<E> node = first;
            for (int i = 0; i < index; i++) {
                node = node.next;
            }
            return node;
        }else {//往前
            Node<E> node = last;
            for (int i = size - 1; i > index; i--) {
                node = node.prev;
            }
            return node;
        }
    }
        
    ......
}

清空元素 - clear()

需将新增属性last置为null

public class LinkedList<E> extends AbstractList<E>{
    ......
    
    /**
     * 清除所有元素
     */
    public void clear(){
        size = 0;
        first = null;
        last = null;
    }
        
    ......
}

添加元素 - add(int index, E element)

• 假定插入位置原结点为oldNode（下图2号结点），上一个结点为prevNode（下图1号结点），新结点为node

• prevNode的next现在为node

• oldNode的prev现在为node

• node的prev即为oldNode的prev

• node的next为oldNode

• 特殊情况，插入在最前面：

  • 如果oldNode的prev为null，那么oldNode为原头结点。那么双向链表的first属性需改为node

• 插入在最后面：

  • node的prev为双向链表的last，next为null，同时last需改为node
  • 如果原链表为空，则双向链表的first和last都为node

public class LinkedList<E> extends AbstractList<E>{
    ......
    
    /**
     * 往index位置添加元素
     * @param index
     * @param element
     */
    public void add(int index, E element){
        //边界判断
        rangeCheckForAdd(index);
        // size == 0
        // index == 0
        if (index == size){//往最后添加元素
            Node<E> oldLast = last;
            last = new Node<>(element,oldLast,null);
            if (oldLast == null){//这是链表的第一个元素
                first = last;
            }else {
                oldLast.next = last;
            }
        }else {// 正常添加元素
            //插入位置的原结点，即为新节点的next节点
            Node<E> next = node(index);
            //新添加结点的上一个节点，即为该位置原节点的上一个节点
            Node<E> prev = next.prev;
            //创建新结点
            Node<E> node = new Node<>(element,prev,next);
            //原结点的上一个结点，为新添加结点
            next.prev = node;
            if (prev == null){//index == 0 即添加的是第一个
                first = node;
            }else {
                //原结点上一个结点的next，即为新添加节点
                prev.next = node;
            }
        }

        size++;
    }
        
    ......
}

删除元素 - remove(int index)

• 删除结点, 只需要让被删除结点的前一个结点与后一个结点之间链接, 同时去掉被删除结点引用
• 需要注意的是, 第0个结点和最后一个结点要特殊处理

public class LinkedList<E> extends AbstractList<E>{
    ......
    
    /**
     * 删除index位置对应的元素
     * @param index
     * @return
     */
    public E remove(int index){
        //边界判断
        rangeCheck(index);
        //删除的结点
        Node<E> node = node(index);
        //删除结点的上一个结点
        Node<E> prev = node.prev;
        //删除结点的下一个结点
        Node<E> next = node.next;
        //删除结点, 只需去掉对这个结点的引用
        if (prev == null){//index == 0 即删除的是第一个
            first = next;
        }else {
            prev.next = next;
        }
        if (next == null){//index == size - 1 即删除的是最后一个
            last = prev;
        }else {
            next.prev = prev;
        }
        size --;
        return node.element;
    }
        
    ......
}

完整代码 --- 双向链表

/**
 * 双向链表的实现
 * @param <E> 泛型
 */
public class LinkedList<E> extends AbstractList<E> {
    /**
     * 元素所在的结点
     */
    private Node<E> first;
    //增加last节点
    private Node<E> last;

    /**
     * 内部类 结点
     * @param <E>
     */
    private static class Node<E>{
        E element;//元素
        Node<E> prev;//增加上一个元素地址
        Node<E> next;//下个元素的地址
        public Node(E element, Node<E> prev,Node<E> next) {
            this.element = element;
            this.prev = prev;
            this.next = next;
        }
    }

    /**
     * 返回index位置对应的元素
     * @param index
     * @return
     */
    public E get(int index){
        return node(index).element;
    }
    /**
     * 设置index位置的元素
     * @param index
     * @param element
     * @return
     */
    public E set(int index, E element){
        Node<E> node = node(index);
        E old = node.element;
        node.element = element;
        return old;
    }

    /**
     * 往index位置添加元素
     * @param index
     * @param element
     */
    public void add(int index, E element){
        //边界判断
        rangeCheckForAdd(index);
        // size == 0
        // index == 0
        if (index == size){//往最后添加元素
            Node<E> oldLast = last;
            last = new Node<>(element,oldLast,null);
            if (oldLast == null){//这是链表的第一个元素
                first = last;
            }else {
                oldLast.next = last;
            }
        }else {// 正常添加元素
            //插入位置的原结点，即为新节点的next节点
            Node<E> next = node(index);
            //新添加结点的上一个节点，即为该位置原节点的上一个节点
            Node<E> prev = next.prev;
            //创建新结点
            Node<E> node = new Node<>(element,prev,next);
            //原结点的上一个结点，为新添加结点
            next.prev = node;
            if (prev == null){//index == 0 即添加的是第一个
                first = node;
            }else {
                //原结点上一个结点的next，即为新添加节点
                prev.next = node;
            }
        }

        size++;
    }
    /**
     * 删除index位置对应的元素
     * @param index
     * @return
     */
    public E remove(int index){
        //边界判断
        rangeCheck(index);
        //删除的结点
        Node<E> node = node(index);
        //删除结点的上一个结点
        Node<E> prev = node.prev;
        //删除结点的下一个结点
        Node<E> next = node.next;
        //删除结点, 只需去掉对这个结点的引用
        if (prev == null){//index == 0 即删除的是第一个
            first = next;
        }else {
            prev.next = next;
        }
        if (next ==null){//index == size - 1 即删除的是最后一个
            last = prev;
        }else {
            next.prev = prev;
        }
        size --;
        return node.element;
    }

    /**
     * 查看元素的位置
     * @param element
     * @return
     */
    public int indexOf(E element){
        // 取出头结点
        Node<E> node = first;
        if(element ==null){// 当element为null时的处理
            // 遍历节点, 找到存储为null的节点, 返回索引
            for (int i = 0; i < size; i++) {
                if (node.element == null) return i;
                node = node.next;
            }
        }else {
            // 遍历节点, 找到存储的元素与指定元素相等的节点, 返回索引
            for (int i = 0; i < size; i++) {
                if (element.equals(node.element)) return i;
                node = node.next;
            }
        }

        return ELEMENT_NOT_FOUND;
    }
    /**
     * 清除所有元素
     */
    public void clear(){
        size = 0;
        first = null;
        last = null;
    }

    /**
     * 获取index位置对应的节点对象
     * @param index
     * @return
     */
    private Node<E> node(int index){
        rangeCheck(index);
        //往后
        if (index < (size >> 1)){
            Node<E> node = first;
            for (int i = 0; i < index; i++) {
                node = node.next;
            }
            return node;
        }else {//往前
            Node<E> node = last;
            for (int i = size - 1; i > index; i--) {
                node = node.prev;
            }
            return node;
        }
    }

    /**
     * 打印
     * @return
     */
    @Override
    public String toString() {
        //Size = ? , [1, 2, 3]
        StringBuilder string = new StringBuilder();
        string.append("size=").append(size).append(", [");
        Node<E> node = first;
        for (int i = 0; i < size; i++) {
            if (i != 0){
                string.append(", ");
            }
            string.append(node.element);
            node = node.next;
        }
        string.append("]");
        return string.toString();
    }
}

双向链表和单向链表对比

粗略对比一下删除的操作数量：操作数量缩减了近一半

有了双向链表，单向链表是否就没有任何用处了？

• 并非如此，在哈希表的设计中就用到了单链表
• 至于原因，在哈希表中会详细讲解

双向链表 vs 动态数组

动态数组：开辟、销毁内存空间的次数相对较少，但可能造成内存空间浪费（可以通过缩容解决）
双向链表：开辟、销毁内存空间的次数相对较多，但不会造成内存空间的浪费

• 如果频繁在尾部进行添加、删除操作，动态数组、双向链表均可选择
• 如果频繁在头部进行添加、删除操作，建议选择使用双向链表
• 如果有频繁的 (在任意位置)添加、删除操作，建议选择使用双向链表
• 如果有频繁的查询操作（随机访问操作），建议选择使用动态数组