手工实现LinkedList,包含LinkedList和LinkedListTest（上）

1、实现思路，使用指针将他们串联起来，像一条链子一样，用指针思想，节点思想

2、实现了链表的增删改查

3、环境准备，

linkedlist全局变量如下

    //头结点
    private Node<E> first;
    //元素个数
    private int size;

节点内部类代码片段如下

 //节点内部类
    private static class Node<E> {
        //父节点对象
        public Node<E> parent;
        //下一个节点对象
        public Node<E> next;
        //元素
        public E element;

        public Node(Node<E> parent, E element) {
            this.parent = parent;
            this.element = element;
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder();
            sb.append("_").append(element).append("_");

            if (next != null) {
                sb.append(next.element);
            } else {
                sb.append("null");
            }
            return sb.toString();
        }
    }

4、具体实现细节

4.1添加的实现：

4.1.1添加的思路

首先考虑特殊情况的添加，一个是末尾，一个是开头

开头的情况：没有父节点，也没有next节点

直接创建一个节点对象，将值传给节点对象，将节点对象复制给frist节点

末尾的情况，有父节点，没有next节点

先通过索引（索引值为size）,找到对应的节点对象，拿到节点对象后，此节点为新创建节点的父节点

创建一个节点对象，传入一个父节点，元素值

图解如下：

 假设我们要在三号元素后追加一个元素，则首先创建节点，并赋值

 赋值后，让3的next指向111，

 立刻让111的next指向4

如此就完成添加 

4.1.2添加的注意事项

考虑以下的因素，索引是否合法，

添加完后，size要加一

4.1.3实现代码片段

添加前的检查方法

    /**
     * description 判断索引是否合法
     * @param index 传入需要验证的索引
     */
    private boolean isOUtOfBound(int index) {
        return index > size || index < 0;
    }

添加节点前创建节点的方法如下

    /**
     * description  创建一个节点对象
     *
     * @param parent 父节点对象，节点对应的元素值
     * @return 节点对象
     */
    private Node<E> createNode(Node<E> parent, E element) {
        return new Node<>(parent, element);
    }

在指定位置添加的（不是开头的情况，需要先找到其父节点，找父节点的方法如下：）

    /**
     * description 根据索引获取节点对象
     *
     * @param index 需要获取节点对象的索引值
     * @return 一个节点对象
     */
    private Node<E> getNode(int index) {
        if (first == null) return null;
        Node<E> node = first;
        for (int i = 0; i < index - 1; i++) {
            node = node.next;
        }
        return node;
    }

添加方法如下

  /**
     * description 在指定位置追加加元素
     * @param   index 用于指定添加元素的位置
     * @param element 欲添加的元素
     */
    public void add(int index, E element) {
        if (isOUtOfBound(index)) return;
        if (index==0||index==size) {
            if (index==0){
                first = createNode(null, element);
            }else {
                Node<E> node = getNode(size);
                assert node != null;
                node.next= createNode(node, element);
            }
        }else {
            Node<E> parent = getNode(index);
            assert parent != null;
            Node<E> next = parent.next;
            Node<E> node = createNode(parent, element);
            parent.next=node;
            node.next=next;
        }
        size++;
    }

在末尾添加的方法

    /**
     * description 在末尾追加元素
     * @param   element 欲添加的元素
     */
    public void add(E element) {
        add(size,element);
    }

4.1.4测试用例代码

    public static void main(String[] args) {
        MyLinkedList<Integer>  list = new MyLinkedList<>();

        for (int i = 0; i < 5; i++) {
            list.add(i,i+5);
        }
        list.add(2,0002);
        for (int i = 0; i < 3; i++) {
            list.add(i+10);
        }
      System.out.println(list);
    }

4.1.5测试结果

 4.2元素查看到实现

4.2.1思路：循环遍历元素

找到对应索引的元素，用for循环，找到相对应的索引返回元素值

找到对应元素的索引，用while循环，找到对应的元素返回其索引值

4.2.2注意：依旧要判断索引是否合法

4.2.3代码实现（找到对应索引的元素）

找到对应的节点对象代码块

    /**
     * description 根据索引获取节点对象
     *
     * @param index 需要获取节点对象的索引值
     * @return 一个节点对象
     */
    private Node<E> getNode(int index) {
        if (first == null) return null;
        Node<E> node = first;
        for (int i = 0; i < index - 1; i++) {
            node = node.next;
        }
        return node;
    }

找到对应的元素代码块

    /**
     * description 根据索引查看元素，并返回对应的元素值
     *
     * @param index 要查看的索引
     * @return 对应索引的元素值
     */
    public E getElement(int index) {
        if (isOUtOfBound(index)) return null;
        assert getNode(index) != null;
        return getNode(index).element;
    }

4.2.4代码的实现（找到对应元素的索引）

    /**
     * description 根据元素查看索引
     * @param element 欲查找的元素
     * @return 返回索引
     */
    public int getIndex(E element) {
        Node<E> node = first;
        int index = 0;
        while (node != null) {
            if (node.element.equals(element)) return index;
            node = node.next;
            index++;
        }
        return ELEMENT_DOES_NOT_EXIST;
    }

有关删除和修改的代码块请看：手工实现LinkedList,包含LinkedList和LinkedListTest（中）