单链表的实现

越努力，越幸运！！！
如果本文有哪些不对的地方，欢迎各位大佬指正，谢谢！

一、何为单链表

单链表也属于线性结构，所以又称为线性链表。线性链表的存储结构特点是用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的）。

单链表中存储的并不是元素本身，而是一个元素节点(node)，该节点中有两部分组成：数据域、指针域。数据域中存储的就是元素数据，而指针域中存储的是下一个元素节点的地址引用。

单链表就是有N个元素节点共同串联起来的，就像一个链子一般，单又由于只是用一个指针来串联，所以称之为单链表。

单链表结构图

二、单链表的具体实现

package com.shadow.list;
import java.util.Iterator;
import java.util.NoSuchElementException;
/**
 * <h>单链表的具体实现<h/>
 *
 * @author Shadow
 * @date 2021/3/17 11:01
 */
public class SingleLinkedList<E> implements List<E> {

    /** 单链表的长度，即节点个数 **/
    private int size;
    
    /** 单链表的首节点 **/
    private Node<E> first;
    
    /** 单链表的尾节点 **/
    private Node<E> last;
    
    @Override
    public boolean empty() {
        return size() == 0;
    }
    
    @Override
    public int size() {
        return size;
    }
    
    @Override
    public void add(E data) {
        Node<E> newNode = new Node<>(data, null);
        // 如果单链表为空，则首节点和尾节点都为newNode
        if (this.empty()) {
            first = last = newNode;
        } else {
            // 单链表不为空，则追加到链表尾部，并将尾节点替换为新节点
            last = last.next = newNode;
        }
        size ++;
    }
    
    @Override
    public void insert(int index, E data) {
        checkIndexForInsert(index);
        // 如果插入位置是在链表尾部追加，则直接新增
        if (index == size()) {
            add(data);
        } else {
            Node<E> newNode = new Node<>(data, null);
            Node<E> node = getNode(index);
            newNode.next = node.next;
            node.next = newNode;
            size ++;
        }
    }
    
    private void checkIndexForInsert(int index) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException();
        }
    }
    
    private void checkIndex(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException();
        }
    }
    
    @Override
    public E get(int index) {
        return getNode(index).data;
    }
    
    private Node<E> getNode(int index) {
        checkIndex(index);
        Node<E> node = first;
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        return node;
    }
    
    @Override
    public int getFirstIndex(E data) {
        Node<E> node = first;
        if (data == null) {
            for (int i = 0; i < size; i++) {
                if (node.data == null) {
                    return i;
                }
                node = node.next;
            }
        } else {
            for (int i = 0; i < size; i++) {
                if (data.equals(node.data)) {
                    return i;
                }
                node = node.next;
            }
        }
        return -1;
    }
    
    @Override
    public int getLastIndex(E data) {
        Node<E> node = first;
        int lastIndex = -1;
        if (data == null) {
            for (int i = 0; i < size; i++) {
                if (node.data == null) {
                    lastIndex = i;
                }
                node = node.next;
            }
        } else {
            for (int i = 0; i < size; i++) {
                if (data.equals(node.data)) {
                    lastIndex = i;
                }
                node = node.next;
            }
        }
        return lastIndex;
    }
    
    @Override
    public void delete(E data) {
        Node<E> node = first;
        if (data == null) {
            for (int i = 0; i < size; i++) {
                if (node.data == null) {
                    if (i == 0) {
                        delete(i);
                    } else {
                        delete(i - 1);
                    }
                }
                node = node.next;
            }
        } else {
            for (int i = 0; i < size; i++) {
                if (data.equals(node.data)) {
                    if (i == 0) {
                        delete(i);
                    } else {
                        delete(i - 1);
                    }
                }
                node = node.next;
            }
        }
    }
    
    @Override
    public E delete(int index) {
        checkIndex(index);
        // 获取删除位置的节点
        Node<E> node = getNode(index);
        // 删除的是第一个元素
        if (index == 0) {
            first = first.next;
        } else if (index == size() - 1){
            // 获取删除位置的前一个节点
            last = getNode(index - 1);
            last.next = null;
        } else {
            // 获取删除位置的前一个节点
            Node<E> lastNode = getNode(index - 1);
            lastNode.next = node.next;
        }
        size --;
        return node.data;
    }
    
    @Override
    public boolean contains(E data) {
        Node<E> node = first;
        if (data == null) {
            for (int i = 0; i < size; i++) {
                if (node.data == null) {
                    return true;
                }
                node = node.next;
            }
        } else {
            for (int i = 0; i < size; i++) {
                if (data.equals(node.data)) {
                    return true;
                }
                node = node.next;
            }
        }
        return false;
    }
    
    @Override
    public Iterator<E> iterator() {
        return new Iter();
    }
    
    /** 单链表节点 **/
    private class Node<E> {
        
        // 数据域，存储元素数据
        private E data;
        
        // 指针域，存储下一个节点的地址
        private Node<E> next;
        
        public Node() {}
        
        public Node(E data, Node<E> next) {
            this.data = data;
            this.next = next;
        }
    }
    
    /**
    * 迭代器实现类
    */
    private class Iter implements Iterator<E> {
    
        private int cursor;
        
        @Override
        public boolean hasNext() {
            return cursor < size;
        }
        
        @Override
        public E next() {
            if (cursor > size) {
                throw new NoSuchElementException();
            }
            return get(cursor++);
        }
    }
}

三、总结

1、单链表的特点

1. 单链表中存放的是每个节点，每个节点有两个区域：数据域和指针域。
2. 由于单链表的存储地址不一定连续，可能是分散的，而且每个元素值是通过指针的方式链接起来的，所以单链表的新增和删除的速度会很快，只需要拆开一个链重新链接即可，时间复杂度为O(1)。但是，查找元素就会很慢，必须从首节点开始遍历，直到找到对应的元素值，时间复杂度为O(n)。

您都看到这了？如何觉得写的还行，不妨给个赞？

参考文献：数据结构（C语言版）（第2版）-- 2.5 线性表的链式表示和实现