【手撕算法】 双向链表

package test;

import org.junit.Test;

import java.util.Iterator;

public class DoubleList<T> {
    int size;
    Node<T> head;
    Node<T> last;

    private static class Node<T>{
        T value;
        Node<T> pre;
        Node<T> next;
        public Node(T value,Node<T> pre,Node<T> next){
            this.value = value;
            this.pre = pre;
            this.next = next;
        }
    }

    public void add(T value){ //在尾部添加元素
        Node newNode = new Node(value,last,null);
        if(last == null){
            head = newNode;
        }else {
            last.next = newNode;
        }
        last = newNode;
        size++;
    }

    public void add(T value,int index){
        chekIndex(index);
        if(index == size){
            add(value);
            return;
        }
        Node<T> nextNode = getNode(index); //上面已经判断过，nextNode不会不存在（不存在说明是将本元素加在末尾）
        Node<T> preNode = nextNode.pre;
        Node<T> newNode = new Node<>(value,preNode,nextNode);
        if(preNode == null){ //是插在头部
            head = newNode;
            nextNode.pre = newNode;
        }else {
            preNode.next = newNode;
            nextNode.pre = newNode;
        }
        size++;
    }

    private Node<T> getNode(int index) {
        //判断index下标是在整个链表前半段还是后半段。
        //如果是前半段，cur指向链表的头指针head，从头部遍历循环到index的位置，返回index的节点。
        //如果是后半段，cur指向链表的尾指针last， 从尾部遍历循环到index的位置，返回index的节点。
        if(index<(size>>1)){
            Node<T> cur = head;
            for(int i=0; i<index;i++){
                head = head.next;
            }
            return cur;
        }else {
            Node<T> cur = last;
            for (int i = size - 1; i > index; i--) {
                cur = cur.pre;
            }
            return cur;
        }
    }

    private void chekIndex(int index) {
        if(index<0 || index>size){
            throw new IndexOutOfBoundsException("out of bounds");
        }
    }


    public T remove(int index){ //**************仔细看
        if(index < 0 || index >= size){
            throw new IndexOutOfBoundsException("out of bound");
        }
        Node<T> delete = getNode(index);
        Node<T> preNode = delete.pre;
        Node<T> nextNode = delete.next;
        if(preNode == null){ //1、处理preNode和deleteNode之间的连接关系
            head = nextNode;
        }else {
            preNode.next = nextNode;
            delete.pre = null ; //免得它还可以访问身边的节点
        }
        if(nextNode == null){ //2、处理nextNode和deleteNode之间的连接关系
            last = preNode;
        }else {
            nextNode.pre = preNode;
            delete.next = null;
        }
        T element = delete.value ;
        delete.value = null;//防止还能访问元素，方便垃圾回收
        size--;
        return element;
    }

    @Test
    public void test()throws Exception{ // 自己测试代码
        DoubleList<Integer> d = new DoubleList<>();
        d.add(1);
        d.add(2);
        d.add(3);
        d.add(4);
        d.add(5);
        d.add(6);
        d.add(1000,3);
        System.out.println("geshu"+d.getSize());
        d.remove(8);
//        d.remove(1);
        Node cur = d.getHead();

        while (cur!=null){
            System.out.println(cur.value);
            cur = cur.next;
        }
    }


}