【java】实现链表的增删查（含泛型）

链表是线性的数据结构，其在内存中是随机存储的。查找的时间复杂度为O(n),增删(不计入查找)的时间复杂度是O(1)。
说数组和链表哪一个更好，根本没办法比较。若是对处在某位置的元素进行操作，链表和数组其实时间复杂度并没什么区别。但若是要求对值为***的元素进行操作，明显是链表时间复杂度更低。

单向链表：

单向链表中插入节点的方法：头插法、尾插法、中间插入

1、使用泛型创建Node.class

public class Node <E> {
    E data;
    Node<E> next;
    public Node(E data){
        this.data=data;
    }
}

2、实现链表的增删查

public class LinkedList<E> {
    private Node<E> head;
    private Node<E> last;
    private int size;

    /**
     * 插入元素
     * @param data
     * @param index
     */
    public void insert(E data,int index){
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("超出链表节点范围！");
        }
        Node<E> insertNode=new Node<>(data);
        if (index == 0) {
            insertNode.next=head;
            head=insertNode;
            if(size==0){
                last=head;
            }
        }
        else if (index == size) {
            last.next=insertNode;
            last=insertNode;
            insertNode=null;
        }
        else{
            Node preNode=get(index-1);
            Node<E> nextNode=preNode.next;
            preNode.next=insertNode;
            insertNode.next=nextNode;
        }
        size++;
    }

    /**
     * 删除元素
     * @param index
     */
    public void remove(int index){
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("超出链表节点范围！");
        }
        if (index == 0) {
            head=head.next;
        }
        else if (index == size) {
            last=get(index-1);
        }
        else{
            Node<E> preNode=get(index-1);
            preNode.next=preNode.next.next;
        }
        size--;
    }

    /**
     * 查找元素
     * @param index
     * @return
     */
    public Node<E> get(int index) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("超出链表节点范围！");
        }
        Node<E> node=head;
        for(int i=0;i<index;i++){
            node=node.next;
        }
        return node;
    }

    /**
     * 遍历链表
     */
    public void output(){
        Node<E> node=head;
        for(int i=0;i<size;i++){
            System.out.println(node.data);
            node=node.next;
        }
    }

    public int getSize(){
        return size;
    }

3、具体例子

public void demo01(){
        LinkedList<Integer> list = new LinkedList<>();
        list.insert(10,0);
        list.insert(12, 1);
        list.insert(13, 2);
        list.insert(9, 3);
        list.insert(16, 2);
        list.insert(18, 0);
        list.remove(list.getSize()-1);
        list.output();
    }

public void demo02(){
        LinkedList<String> list = new LinkedList<>();
        list.insert("a",0);
        list.insert("b",1);
        list.insert("c",2);
        list.insert("d",3);
        list.insert("e",4);
        list.insert("f",0);
        list.insert("g",2);
        list.output();
    }