class Node{
    String val;
    Node pre;  //双向
    Node next;
    Node(String val){
        this.val = val;
    }
}
public class MyLinkedList {
    private Node head;  //头结点
    private Node last;  //尾结点
    private int size;   //链表中当前元素个数
    public boolean add(String e){
        //将元素装到结点对象中
        Node node = new Node(e);
        if(head == null){
            head = last = node;
        }else{
            node.pre = last;
            last.next = node;
            last = node;
        }
        size++;
        return true;
    }

    public void add(int index,String e){
        //判断是否是合法下标
        if(index < 0 || index > size()){
            throw new IndexOutOfBoundsException("下标越界"+index);
        }
        Node node = new Node(e);
        if(head == null){
            head = last = node;
        }else if(index == 0){
            node.next = head;
            head.pre = node;
            head = node;
        }else if(index == size()){
            last.next = node;
            node.pre = last;
            last = node;
        }else{
            //需要得到index处结点
            Node cur = getNodeByIndex(index);
            Node pre = cur.pre;
            pre.next = node;
            node.next = cur;
            node.pre = pre;
            cur.pre = node;
        }
        size++;
    }

    private Node getNodeByIndex(int index){
        Node cur = head;
        for(int i = 0;i < index;i++){
            cur = cur.next;
        }
        return cur;
    }

    public String remove(int index){
        //判断是否是合法下标
        if(index < 0 || index >= size()){
            throw new IndexOutOfBoundsException("下标越界"+index);
        }
        String v = null;
        if(size() == 1){
            v = head.val;
            head = last = null;
        }else if(index == 0){
            v = head.val;
            head = head.next;
            head.pre = null;
        }else if(index == size()-1){
            v = last.val;
            last = last.pre;
            last.next = null;
        }else{
            Node cur = getNodeByIndex(index);
            v = cur.val;
            Node pre = cur.pre;
            Node next = cur.next;
            pre.next = next;
            next.pre = pre;
        }
        size--;
        return v;
    }

    public boolean remove(String e){
        Node cur = head;
        while(cur != null){
            if(cur.val.equals(e)){
                Node pre = cur.pre;
                Node next = cur.next;
                if(pre == null){
                    //删除的是头结点
                   head = head.next;
                }else{
                    pre.next = next;
                }
                if(next == null){
                    last = last.pre;
                }else{
                    next.pre = pre;
                }
                size--;
                return true;
            }
        }
        return false;
    }
    
    public int size(){
        return size;
    }

    public String get(int index){
        //判断是否是合法下标
        if(index < 0 || index >= size()){
            throw new IndexOutOfBoundsException("下标越界"+index);
        }
        Node cur = head;
        for(int i = 0;i < index;i++){
            cur = cur.next;
        }
        return cur.val;
    }

    public String set(int index,String e){
        //判断是否是合法下标
        if(index < 0 || index >= size()){
            throw new IndexOutOfBoundsException("下标越界"+index);
        }
        Node node = head;
        for(int i = 0;i < index;i++){
            node = node.next;
        }
        String oldVal = node.val;
        node.val = e;
        return oldVal;
    }

    public boolean contains(String e){
        return indexOf(e) != -1;
    }

    public int indexOf(String e){
        Node cur = head;
        for(int i = 0;i < size();i++){
            if(cur.val.equals(e)){
                return i;
            }
            cur = cur.next;
        }
        return -1;
    }

    public int lastIndexOf(String e){
        //从后往前遍历，第一次遇到指定的元素即为正向遍历最后一次遇到指定元素
        Node cur = last;
        for(int i = size()-1;i >= 0;i--){
            if(cur.val.equals(e)){
                return i;
            }
            cur = cur.pre;
        }
        return -1;
    }

    public boolean isEmpty(){
        return size() == 0;
    }
}