MyLinkedList

package soul.demo.lists;

import java.util.Collection;
import java.util.Deque;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

class MyLinkedList<E> implements List<E>, Deque<E> {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
//        new MyLinkedList.Node<String>(null,null,null);
    }
    
    private Node<E> firstNode=null;
    private Node<E> lastNode=null;
    private int size=0;
    
    
    @SuppressWarnings("hiding")
    private class Node<E>{
        E element;
        Node<E> pre;
        Node<E> next;
        
        Node(Node<E> _pre,E _element,Node<E> _next){
            this.pre=_pre;
            this.element=_element;
            this.next=_next;
        }
    }
//    private static class Node<E> {
//        E item;
//        Node<E> next;
//        Node<E> prev;
//
//        Node(Node<E> prev, E element, Node<E> next) {
//            this.item = element;
//            this.next = next;
//            this.prev = prev;
//        }
//    }
    /**
     * 构造一个空列表
     */
    MyLinkedList(){
        
    }
    
    /**
     * 构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列
     * @param c
     */
    MyLinkedList(Collection<? extends E> c){
        
    }
    
    /**
     * 将指定元素插入此列表的开头
     */
    @Override
    public void addFirst(E e) {
        // TODO Auto-generated method stub
        firstNode=addNode(null,e,firstNode);
    }
    
    /**
     * 将指定元素添加到此列表的结尾
     */
    @Override
    public void addLast(E e) {
        // TODO Auto-generated method stub
        addNode(lastNode,e,null);
    }
    
    /**
     * 增加元素，凡是单个增加元素节点都通过该方法
     * @param pre
     * @param e
     * @param next
     * @return
     */
    private Node<E> addNode(Node<E> pre,E e,Node<E> next){
        Node<E> newNode=new Node<E>(pre,e,next); 
        if(size==0){
            firstNode=newNode;
            lastNode=newNode;
        }
        if(next==null){
            lastNode.next=newNode;
            lastNode=newNode;
            
        }
        if(pre==null){
            firstNode.pre=newNode;
            firstNode=newNode;
        }
        size++;
        return newNode;
    }
    /**
     * 在此列表的开头插入指定的元素
     */
    @Override
    public boolean offerFirst(E e) {
        // TODO Auto-generated method stub
        addFirst(e);
        return true;
    }

    /**
     *  在此列表末尾插入指定的元素
     */
    @Override
    public boolean offerLast(E e) {
        // TODO Auto-generated method stub
        addLast(e);
        return true;
    }

    /**
     *  移除并返回此列表的第一个元素
     */
    @Override
    public E removeFirst() {
        // TODO Auto-generated method stub
        Node<E> oldFirst=firstNode;
        firstNode=firstNode.next;
        return removeNode(oldFirst);
    }

    /**
     * 移除单个元素  凡是单个移除动作都要经过该方法
     * @param e
     * @return
     */
    private E removeNode(Node<E> node){
        node.pre.next=node.next;
        node.next.pre=node.pre;
        size--;
        return node.element;
    }
    @Override
    /**
     * 移除并返回该列表的最后一个元素
     * @return
     */
    public E removeLast() {
        // TODO Auto-generated method stub
        Node<E> oldLast=lastNode;
        lastNode=oldLast.pre;
        return removeNode(oldLast);
    }

    /**
     * 获取并移除此列表的第一个元素；如果此列表为空，则返回 null
     */
    @Override
    public E pollFirst() {
        // TODO Auto-generated method stub
        return removeFirst();
    }

    /**
     * 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null
     */
    @Override
    public E pollLast() {
        // TODO Auto-generated method stub
        return removeLast();
    }

    /**
     * 返回此列表的第一个元素
     */
    @Override
    public E getFirst() {
        // TODO Auto-generated method stub
        return firstNode.element;
    }

    /**
     * 返回此列表的最后一个元素
     */
    @Override
    public E getLast() {
        // TODO Auto-generated method stub
        return lastNode.element;
    }

    /**
     * 获取但不移除此列表的第一个元素；如果此列表为空，则返回 null
     */
    @Override
    public E peekFirst() {
        // TODO Auto-generated method stub
        return getFirst();
    }

    /**
     * 获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null
     */
    @Override
    public E peekLast() {
        // TODO Auto-generated method stub
        return getLast();
    }

    /**
     * 从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）
     * @param o
     * @return
     */
    @Override
    public boolean removeFirstOccurrence(Object o) {
        // TODO Auto-generated method stub
        return false;
    }

    /**
     * 从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）
     */
    @Override
    public boolean removeLastOccurrence(Object o) {
        // TODO Auto-generated method stub
        return false;
    }

    /**
     * 将指定元素添加到此列表的末尾（最后一个元素）
     */
    @Override
    public boolean offer(E e) {
        // TODO Auto-generated method stub
        addLast(e);
        return true;
    }

    /**
     * 获取并移除此列表的头（第一个元素）
     */
    @Override
    public E remove() {
        // TODO Auto-generated method stub
        return removeFirst();
    }

    /**
     *  获取并移除此列表的头（第一个元素）
     */
    @Override
    public E poll() {
        // TODO Auto-generated method stub
        return removeFirst();
    }

    /**
     * 获取但不移除此列表的头（第一个元素）
     */
    @Override
    public E element() {
        // TODO Auto-generated method stub
        return getFirst();
    }

    /**
     * 获取但不移除此列表的头（第一个元素）
     */
    @Override
    public E peek() {
        // TODO Auto-generated method stub
        return getFirst();
    }

    /**
     *  将元素推入此列表所表示的堆栈
     */
    @Override
    public void push(E e) {
        // TODO Auto-generated method stub
        addFirst(e);
    }
    
    /**
     * 从此列表所表示的堆栈处弹出一个元素（第一个）
     */
    @Override
    public E pop() {
        // TODO Auto-generated method stub
        return removeFirst();
    }

    /**
     * 返回以逆向顺序在此双端队列的元素上进行迭代的迭代器
     */
    @Override
    public Iterator<E> descendingIterator() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public ListIterator<E> listIterator(int index) {
        // TODO Auto-generated method stub
        return null;
    }

    /**
     * 返回此列表的元素数
     */
    @Override
    public int size() {
        // TODO Auto-generated method stub
        return size;
    }

    /**
     * 将指定元素添加到此列表的结尾
     */
    public boolean add(E e){
        addLast(e);
        return true;
    }
    
    /**
     * 在此列表中指定的位置插入指定的元素
     */
    public void add(int index,E element){
        //检查index
        Node<E> needNode=firstNode;
        for(int i=0;i<index-1;i++){
            needNode=needNode.next;
        }
        Node<E> newNode=addNode(needNode.pre,element,needNode);
        needNode.pre.next=newNode;
        needNode.pre=newNode;
    }
    
    /**
     * 添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序
     */
    public boolean addAll(Collection<? extends E> c){
        return false;
    }
    
    /**
     * 将指定 collection 中的所有元素从指定位置开始插入此列表
     */
    public boolean addAll(int index,Collection<? extends E> c){
        return false;
    }
    
    /**
     * 从此列表中移除所有元素
     */
    public void clear(){
        for (Node<E> x = firstNode; x != null; ) {
            Node<E> next = x.next;
            x.element = null;
            x.next = null;
            x.pre= null;
            x = next;
        }
        firstNode = lastNode = null;
        size = 0;
    }
    
    /**
     * 返回此 LinkedList 的浅表副本
     */
    public Object clone(){
        return null;
    }

    @Override
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return size==0;
    }

    /**
     * 如果此列表包含指定元素，则返回 true
     */
    @Override
    public boolean contains(Object o) {
        // TODO Auto-generated method stub
        return false;
    }

    
    @Override
    public Iterator<E> iterator() {
        // TODO Auto-generated method stub
        return new Itr();
    }

    private class Itr implements Iterator<E>{

        private Node<E> _nextNode=firstNode;
        
        @Override
        public boolean hasNext() {
            // TODO Auto-generated method stub
            return _nextNode!=null;
        }

        @Override
        public E next() {
            // TODO Auto-generated method stub
            E _e=null;
            if(hasNext()){
                _e=_nextNode.element;
                _nextNode=_nextNode.next;
            }
                
            
            return _e;
        }
        
    }
    /**
     * 返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组
     */
    @Override
    public Object[] toArray() {
        // TODO Auto-generated method stub
        return null;
    }

    /**
     * 返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组；返回数组的运行时
     * 类型为指定数组的类型。
     */
    @Override
    public <T> T[] toArray(T[] a) {
        // TODO Auto-generated method stub
        return null;
    }

    /**
     * 从此列表中移除首次出现的指定元素（如果存在）
     */
    @SuppressWarnings("unchecked")
    @Override
    public boolean remove(Object o) {
        // TODO Auto-generated method stub
        removeNode(eToNode((E)o,true));
        return true;
    }

    @Override
    public boolean containsAll(Collection<?> c) {
        // TODO Auto-generated method stub
        return false;
    }

    @Override
    public boolean removeAll(Collection<?> c) {
        // TODO Auto-generated method stub
        return false;
    }

    @Override
    public boolean retainAll(Collection<?> c) {
        // TODO Auto-generated method stub
        return false;
    }

    /**
     * 返回此列表中指定位置处的元素
     */
    @Override
    public E get(int index) {
        // TODO Auto-generated method stub
        return indexToNode(index).element;
    }

    /**
     * 将此列表中指定位置的元素替换为指定的元素
     */
    @Override
    public E set(int index, E element) {
        // TODO Auto-generated method stub
        
        E oldE=indexToNode(index).element;
        E _oldE=oldE;
        oldE=element;
        return _oldE;
    }

    /**
     * 移除此列表中指定位置处的元素
     */
    @Override
    public E remove(int index) {
        // TODO Auto-generated method stub
        return removeNode(indexToNode(index));
    }

    /**
     * 返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1
     */
    @SuppressWarnings("unchecked")
    @Override
    public int indexOf(Object o) {
        // TODO Auto-generated method stub
        return eToIndex((E)o,true);
    }

    /**
     * 返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1
     */
    @SuppressWarnings("unchecked")
    @Override
    public int lastIndexOf(Object o) {
        // TODO Auto-generated method stub
        return eToIndex((E)o,false);
    }

    /**
     *  返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始
     */
    @Override
    public ListIterator<E> listIterator() {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        // TODO Auto-generated method stub
        return null;
    }
    
    private Node<E> eToNode(E e,boolean isFirst){
        Node<E> _node=firstNode;
        Node<E> needNode=null;
        for(int i=0;i<size;i++){
            if(_node.element==e){
                if(isFirst)
                    return _node;
                needNode=_node;
            }

            _node=_node.next;
        }
        return needNode;
    }
    
    private Node<E> indexToNode(int index){
        
        Node<E> _node=firstNode;
        for(int i=0;i<size;i++){
            if(i==index)
                return _node;
            _node=_node.next;
        }
        return null;
    }
    
    private int eToIndex(E e,boolean isFirst){
        
        int needI=-1;
        Node<E> _Node=firstNode;
        
        for(int i=0;i<size;i++){
            if(_Node.element==e){
                if(isFirst)
                    return i;
                needI=i;
            }
        }
        return needI;
    }
}