java手写LinkedList

手写LinkedList

• LinkedList 的底层实现是一个双向链表，内部维护一个，start节点和一个end节点。start节点是用来查询，通过，start.next.next…获取。end节点是用来添加，每次新增元素直接新建节点放到end的后面，使其成为新的end。

package com.work.one.listUtils.impl;

import com.work.one.listUtils.MyList;

/**
 * Created by 廖开雷 on 2020/2/3.
 * LinkList 是一个双向链表
 * 维护一个 start 和一个 end
 * start 是用于 查询 start.next.next...
 * end 是用于添加，end.next
 *
 */
@SuppressWarnings("all")
public class LklLinkLList<E> implements MyList<E> {

    private Node start;

    private Node end;

    private int size = 0;

    /**
     * 添加元素
     * @param e
     */
    @Override
    public void add(E e) {
        if (size == 0) {
            Node newNode = new Node(e, null, null);
            start = newNode;
        } else if (size == 1) {
            Node newNode = new Node(e, start, null);
            end = newNode;
            start.next = end;
        } else {
            Node newNode = new Node(e, end, null);
            end.next = newNode;
            end = newNode;
        }
        size ++ ;
    }

    /**
     * 在指定位置添加索引
     * @param e
     * @param index
     */
    public void add (E e, int index) {
        rangeCheck(index);

        Node node = start;
        Node newNode = new Node(e);
        if (index == 0) {
            newNode.pre = null;
            newNode.next = start;
            start = newNode;
        } else if (index == size - 1) {
            end.next = newNode;
            newNode.pre = end;
            end = newNode;
        } else {
            // 1 2 3 4 5
            for (int i = 0; i < index; i++) {
                node = node.next;
            }
            Node pre = node.pre;
            node.pre = newNode;
            newNode.next = node;
            newNode.pre = pre;
            pre.next = newNode;
        }
        size ++ ;
    }

    /**
     *
     * 根据索引获取对应的值
     * @param index
     * @return
     */
    @Override
    public E get(int index) {
        rangeCheck(index);

        if (index == 0) {
            return start == null ? null : (E)start.value;
        }
        Node nowNode = start;
        for (int i = 0; i < index; i++) {
            if (nowNode.next != null) {
                nowNode = nowNode.next;
            }
        }
        return (E)nowNode.value;
    }

    /**
     * 索引范围检查
     * @param index
     */
    private void rangeCheck(int index) {
        if (index > size) {
            throw new IndexOutOfBoundsException("index out of size");
        }
    }

    /**
     * 移除指定下标的元素
     * @param index
     * @return
     */
    @Override
    public E remove(int index) {
        rangeCheck(index);
        Node node = start;
        if (index == 0) {
            node = start.next;
            node.pre = null;
            start = null;
            start = node;
        } else if (index == size - 1){
            node = end.pre;
            node.next = null;
            end = null;
            end = node;
        } else {
            // 1  2  3  4  5
            for (int i = 0; i < index; i++) {
                node = node.next;
            }
            Node pre = node.pre;
            Node next = node.next;
            pre.next = next;
            next.pre = pre;
        }
        size -- ;
        return (E)node.value;
    }

    @Override
    public int size() {
        return this.size;
    }

    class Node<E> {
        //当前节点存储的值
        E value;

        Node<E> pre;

        Node<E> next;
        public Node (E e, Node pre, Node next) {
            this.value = e;
            this.pre = pre;
            this.next = next;
        }

        public Node (E e) {
            this.value = e;
        }
    }
}