单项链表双向链表

链表是把一个个节点，通过改变节点的指向，达到增删查改，这一个节点，有属性，有方法，说白了就是一个节点类。
第一：创建节点类

这里写代码片
public class MyNode<E>{
    E item;
    MyNode<E> next;
}

//创建自己的链表

这里写代码片
public class MyLinked{
    //第一个节点
    MyNode<E> first;
    //最后一个节点
    MyNode<E> last;
    //增
    public void add(E item){
      //构建节点
      MyNode myNode = new MyNode();
      myNode.next=null;;
     if(last!=null){
        last.next=myNode; 
     }
     if(first==null){
          first = myNode;
      }
          last = myNode;
          size++;
    }
    //删
    public void remove(int index){
     MyNode pre = first;
     for(int i=0;i<index-1;i++){
        pre = pre.next;
    }
    //自己节点
    MyNode<E>self = pre.next;
    //自己下一个节点
    MyNode<E>nextNode = self.next;
    if(nextNode==null){
        pre.next = null;
        pre = last;
    }else{
        pre.next = nexNode; 
    }
    }
    //查
    public E get(int index){
        MyNode<E> myNode = first;
        for(int i=0;i<index;i++){
            myNode = myNode.next; 
            }
            return myNode.item;
    }
    //改
    public void upData(int index,E item){
        MyNode<E> pre = first;
        for(int i=0;i<index;i++){
            pre = pre.next;
        }
          pre.item = item;
    }
}

双向链表

//创建双向链表节点
package coom.huaxin.doub;

public class MyDoubleNode<E> {
    E item;
    MyDoubleNode<E> pre;
    MyDoubleNode<E> next;

    public MyDoubleNode(MyDoubleNode<E> pre, E item, MyDoubleNode<E> next) {

        this.item = item;
        this.pre = pre;
        this.next = next;
    }

}

package coom.huaxin.doub;

public class MyDoubleLinked<E> {
    MyDoubleNode<E> first;
    MyDoubleNode<E> last;
    int size;

    // 增
    public void add(E item) {
        MyDoubleNode<E> l = last;
        MyDoubleNode<E> myDoubleNode = new MyDoubleNode<E>(l, item, null);
        last = myDoubleNode;
        if (l == null) {
            first = myDoubleNode;
        } else {
            l.next = myDoubleNode;
        }
        size++;
    }

    // 删
    public void remove(int index) {
        MyDoubleNode<E> x = first;
        for (int i = 0; i < index; i++) {
            x = x.next;
        }
        // 要删除节点的上一个节点
        MyDoubleNode<E> pre = x.pre;
        // 要删除节点的下一个接点
        MyDoubleNode<E> next = x.next;
        if (pre == null) {
            first = next;
        } else {
            pre.next = next;
            x.pre = null;
        }
        if (next == null) {
            last = pre;
        } else {
            next.pre = pre;
            x.next = null;
        }
        x.item = null;
        size--;
    }

    // 查
    public E get(int index) {
        MyDoubleNode<E> x = first;
        for (int i = 0; i < index; i++) {
            x = x.next;
        }
        return x.item;
    }

    public int getSize() {

        return size;
    }

    // 改
    public void upData(int index, E item) {
        MyDoubleNode<E> x = first;
        for (int i = 0; i < index; i++) {
            x = x.next;
        }
        x.item = item;
    }

    // 插入
    public void insert(int index, E item) {
        MyDoubleNode<E> x = first;
        MyDoubleNode<E> y = last;
        MyDoubleNode<E> myNode = new MyDoubleNode<E>(x, item, null);

        if (index == 0) {
            first = myNode;
            first.next = x;
            x.pre = first;
            // pre.pre = myNode;
        } else if (index == size) {
            last = myNode;
            last.pre = y;
            y.next = last;
        } else {

            for (int i = 0; i < index; i++) {
                x = x.next;
            }
            MyDoubleNode<E> pre = x.pre;
            // MyDoubleNode<E> next = x.next;
            pre.next = myNode;
            myNode.pre = pre;
            x.pre = myNode;
            myNode.next = x;
        }

        myNode.item = item;
        size++;
    }
}