小码哥《恋上数据结构与算法》笔记（二）：链表

个人Github地址

小码哥《恋上数据结构与算法》笔记

极客时间《iOS开发高手课》笔记

iOS大厂面试高频算法题总结

iOS面试资料汇总

参考：小码哥数据结构与算法(二): 链表

数据结构和算法动态可视化

1、链表（LinkedList）

• 链表是一种链式存储的线性表, 全部元素的内存地址不必定是连续的。

2、链表（LinkedList）接口设计

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

public class LinkedList<E> {
    private int size;
    private Node<E> first;
    
    // 元素的数量
    int size(); 
    // 是否为空
    boolean isEmpty();
    // 是否包含某个元素
    boolean contains(E element); 
    // 添加元素到最后面
    void add(E element); 
    // 返回index位置对应的元素
    E get(int index); 
    // 设置index位置的元素
    E set(int index, E element); 
    // 往index位置添加元素
    void add(int index, E element); 
    // 删除index位置对应的元素 
    E remove(int index); 
    // 查看元素的位置
    int indexOf(E element); 
    // 清除全部元素
    void clear();
    
    // 私有类, 链表中的节点
    private class Node<E> {
        E element;
        Node<E> next;
        // 构造方法
        public Node(E element, Node<E> next) {
            this.element = element;
            this.next = next;
        }
    }
}
复制代码

3、链表的实现

一、构造方法

• 链表的建立与动态数组不一样，动态数组在构造时须要传入一个空间属性，来决定这个数组的容量。但链表元素是在添加时才建立的，内存地址不必定是连续的。因此链表不须要在单独设计构造方法，使用默认构造方法便可。

二、添加元素

• 添加数据时，须要建立一个节点存储数据，并将该节点拼接到最后节点的后面，而后size加1。
• 须要区分当前链表没有数据，新节点拼接到first和当前链表有数据，新节点拼接到最后的节点。

public void add(E element) {
    // 当first等于null时, 说明此事没有节点, 因此first引用新节点
    if (first == null) {
    	first = new Node<E>(element, null);
    }
    // 当fitst不等于null时, 说明链表中有节点, 此时获取最后一个节点, 并将该节点的next指向新节点
    else {
        Node<E> node = node(size - 1);
        node.next = new Node<E>(element, null);
    }
    size++;
}
复制代码

三、插入元素

• 插入链表，首先须要建立新节点，而后经过变动插入位置前一个元素next指针指向，插入指定位置便可。
• 须要区分插入到0的位置，使用first指向新节点和插入到非0位置，找到前一个节点进行处理两种状况。

3.一、数组越界

• 插入元素的位置必须不能小于0, 也不能大于等于size，因此咱们在插入元素以前须要先进行索引检查。

protected void outOfBounds(int index) {
    throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
}
	
protected void rangeCheck(int index) {
    if (index < 0 || index >= size) {
        outOfBounds(index);
    }
}
复制代码

• 插入元素代码以下：

public void add(int index, E element) {
    // 检查索引是否越界
    rangeCheckForSize(index);
    // 当插入到0的位置时
    if (index == 0) {
        // 将first指向新节点, 新节点的next指向first以前指向的节点
        first = new Node<E>(element, first.next);
    }else {
        // 找到指定位置前面的节点
        Node<E> prev = node(index - 1);
        // 将前面节点的next指向新节点, 新节点的next指向prev以前指向的节点
        prev.next = new Node<>(element, prev.next);
    }
    size++;
}
复制代码

• 添加元素也能够简写：

public void add(E element) {
    // 元素添加到size位置, 即添加到最后面
    add(size, element);
}
复制代码

四、删除元素

• 首先找到删除节点(delete_node)的前一个节点(pre_node)，而后经过变动(pre_node)节点next指针指向删除节点(delete_node)的下一个节点便可，而后size减1。
• 须要判断是否删除的第0个元素，若是是，则使用first指向第1个节点。

public E remove(int index) {
    // 检查索引是否越界
    rangeCheck(index);
    // 记录须要删除的节点
    Node<E> old = first;
    // 当删除第0个元素时, 将first的next指向索引为`1`的节点便可
    if (index == 0) {
        first = first.next;
    }else {
        // 找到前一个元素
        Node<E> prev = node(index - 1);
        // 记录须要删除的节点
        old = prev.next;
        // 将prev的next指向须要删除节点的后一个节点
        prev.next = old.next;
    }
    // size-1
    size--;
    // 返回删除的元素
    return old.element;
}
复制代码

五、清空元素

• 将first指向null，释放链表全部node，同时size置为0便可。

public void clear() {
    first = null;
    size = 0;
}
复制代码

六、修改元素

• 首先经过遍历链表元素，找到该节点。

private Node<E> node(int index) {
    //越界判断
    rangeCheck(index);
		
    Node<E> node = first;
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
    return node;
}
复制代码

• 而后修改node节点的element便可。

public E set(int index, E element) {
    // 找到对应节点, node方法中已经判断了索引是否越界
    Node<E> node = node(index);
    // 记录旧元素
    E old = node.element;
    // 覆盖元素
    node.element = element;
    // 返回旧元素
    return old;
}
复制代码

七、查找元素

• 找到对应的节点, 取出元素便可。

public E get(int index) {
    // node方法中已经判断了索引是否越界
    return node(index).element;
}
复制代码

八、查找元素索引

• 查找指定元素的索引，须要遍历全部节点，找到节点对应的元素与执行元素相等便可。
• 若是须要支持节点element为null，则须要分两种状况处理。

private static final int ELEMENT_ON_FOUND = -1;
public int indexOf(E element) {
    // 取出头结点
    Node<E> node = first;
    // 当element为null时的处理
    if (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;
        }
    }
    // 没有找到元素对应的节点, 返回ELEMENT_ON_FOUND
    return ELEMENT_ON_FOUND;
 }
复制代码

九、获取链表存储元素的个数

• 获取链表存储元素的个数, 就是size的值。

public int size() {
    return size;
}
复制代码

十、链表是否为空

• 链表是否为空, 只须要判断size是否等于0便可。

public boolean isEmpty() {
    return size == 0;
}
复制代码

十一、判断元素是否存在

• 判断元素是否存在, 只须要判断元素的索引是否为ELEMENT_ON_FOUND便可。

public boolean contains(E element) {
    return indexOf(element) != ELEMENT_ON_FOUND;
}
复制代码

十二、打印链表中存储的数据

public String toString() {
    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();
}
复制代码

到此为止，咱们成功的实现了链表。

4、链表的复杂度

5、leetcode算法题

一、删除链表中的节点

二、反转链表

三、环形链表

四、移除链表元素

五、删除排序链表中的重复元素

六、链表的中间结点