package stack;
import java.util.Iterator;
public class DoubleEndedQueue<DoubleEndedQueueType> implements Iterable<DoubleEndedQueueType>{
    Node first,last;
    private int N;
    private class Node{  
    DoubleEndedQueueType val;
    Node next,prev;
     }
    
    public void addFirst(DoubleEndedQueueType ob){
        Node oldfirst=first;
        first=new Node();
        first.val=ob;
        first.next=oldfirst;
        first.prev=last;
        oldfirst.prev=first;  //NullPointerException
        N++;
    }
    
    public DoubleEndedQueueType removeFirst(){ 
        DoubleEndedQueueType ob = first.val;
        first = first.next;
        first.prev=last;
        N--;
        return ob;
    }
    
    public void addLast(DoubleEndedQueueType ob)throws NullPointerException{
        Node oldlast = last;
        last=new Node();
        last.val=ob;
        oldlast.next=last;     //NullPointerException
        last.prev=oldlast;
        last.next=first;
        N++;}
    public DoubleEndedQueueType removeLast(){
        DoubleEndedQueueType ob = last.val;
        last=last.prev;
        last.next=first;
        N--;
        return ob;}
     
    public void delete(int k){
        if(k<=N && N>0){
        int i=0;
        for(Node x=first;x!=null;x=x.next,i++){
            if(i==k){
               x.next=x.next.next;
               x.next.prev=x.prev;}
        }
      }     
    }  
    
   
    
   public static void main(String[]args) throws NullPointerException{
        DoubleEndedQueue<Character> b = new DoubleEndedQueue<>();
        b.addFirst('A');
        b.addFirst('B');
        b.addFirst('C');
        b.addLast('P');
        
        for (char ch : b) System.out.println(ch);
            
    
    }
   
   
   
   
  private class DoubleEndedQueueIterator implements Iterator<DoubleEndedQueueType> {
        private int i=N;
        private Node current=first;
        @Override
        public boolean hasNext() {return i>0;}
        @Override
        public DoubleEndedQueueType next() {
            DoubleEndedQueueType ob = current.val;
            current=current.next;
            i--;
            return ob;}
        @Override
        public void remove() {
            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
        }

    }
  @Override
    public Iterator<DoubleEndedQueueType> iterator() {
        return new DoubleEndedQueueIterator();
    }
}

public class LinkedQueue<QueueType> implements Iterable<QueueType>{
    private Node first;  //первый в очереди
    private Node last;   //последний в очереди
    private int N;
    boolean isEmpty(){return N==0;}

    @Override
    public Iterator<QueueType> iterator() {
        return new ListIterator();
    }

    private class ListIterator implements Iterator<QueueType>{
 private Node current=first;

        @Override
        public boolean hasNext() {
            return current!=null;
        }
        @Override
        public QueueType next() {
            QueueType val = current.val;
            current=current.next;
            return val;
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
        }
        
    }
    private class Node{
        Node next;  //след узел
        QueueType val;
    }
    public  void enqueue(QueueType val){ //ложим в конец
        Node oldlast=last;
        last = new Node();
        last.val=val;
        last.next=null;
        if(isEmpty())first=last;
        else    oldlast.next=last;
        N++;
        
    }
    public QueueType dequeue(){ //удаление из начала
        QueueType val = first.val;
        first=first.next;
        N--;
        return val;
    }
    public void removeLast(){
        if(first==null)return;
         for(Node x=first;x!=null;x=x.next){
            if(x.next==last){x.next=null;last=x;}
        }
         N--;
    } 
    public void delete(int k){
    if(k<=N && k>0){
        if(k==1)dequeue();
        if(k==N)removeLast();
        else{
            int count=2;
            for(Node n=first;n!=null;n=n.next){
            if(count==k)n.next=n.next.next; 
            count++;}
            }
                    }
    }
    public boolean find(LinkedQueue q, String key){
        for(Node n=first;n!=null;n=n.next){
            if(n.val.toString().equals(key))return true;}
            return false;
    }
    public void removeAfter(int k){
        int count=1;
        for(Node n=first;n!=null;n=n.next){
            if(count==k)n.next=n.next.next;
            count++;
        }
        N--;
    }
    public void removeAfterNode(Node x){
               
        if(x.next!=null){
            x.next=x.next.next;
            N--;}
    }

public class ForTest {
    public static void main(String[]args){
        LinkedQueue<Character> lqueue=new LinkedQueue<>();

        
        for(int i=97;i<123;i++)lqueue.enqueue((char)i);
        lqueue.removeAfterNode('A'); [color=red]//incompatible types: char cannot be converted to LinkedQueue<Character>.Node[/color]
        
        for(char ch:lqueue)System.out.print(ch+" ");
    }
    
}