Iterator 1

Iterator 1 


Concat iterator 
14

Cyclic iterator 
22.28


Filter iterator (positive) 
Predicate 
32.10



Sequence iterator 
Iterator of iterator 
Iterator inner
Iterator outer 

55.12




Even index iterator 
Version 1: 1.05
Version 2: 1.09 




Odd index iterator 
1: 13 


Even value iterator
1.23

What if someone calls hasNext() nonstop ??
1: 25  add a check



Zigzag iterator 
Using cyclic iterator implemented before  
1: 51

Inner = null, in case some on crazy calls for has next()
Next() and hasNext() can be called independently 


Testing 
2.12






=================




// q1 concat two iterators
// iter1: [1,2,3]
// iter2: [4,5,6]
// 1 2 3 4 5 6

static<T> Iterator<T> concat(Iterator<T> iter1, Iterator<T> iter2){
  return new Iterator<T>(){
    @Override
    public boolean hasNext(){
      return iter1.hasNext() || iter2.hasNext();
    }
    
    @Override
    public T next(){
      return iter1.hasNext()? iter1.next() : iter2.next();
    }
  };
}

// q2: cyclic iterator 
// iter1:[1,2,3]
// cyclic:[1,2,3,1,2,3...]

static<T> Iterator<T> cyclic(Iterator<T> iterable){
  return new Iterator<T>(){
    @Override
    public boolean hasNext(){
      return true;
    }
    
    @Override 
    public T next(){
      if(!current.hasNext()){
        current = iterable.iterator();
      }
      return current.next();
    }
  };
}



// q3: filter iterator   没搞明白
// return non negative 
// [1,2,3, -1, 4, 5]
// [1,2,3,4,5]
Predicate<Integer> predicate;

static<T> Iterator<T> filter(Iterator<T> iter, Predicate<T> predicate){
  return new Iterator<T>(){
    @Override
    public boolean hasNext(){
      if(next == null){
        while(iter.hasNext()){
          T t = iter.next();
          if(predicate.test(t)){
            next = t;
            return true;
          }
        }
      }
      return next != null;
    }
    
    @Override
    public T next(){
      if(hasNext()){
        T result = next;
        next = null;
        return result;
      }
      throw new NoSuchElementException();
    }
  };
}

// sequence iterator -> flatten a iterator of itetator 
// {{1,2,3}, {}, {4}, {5,6}} -> {1,2,3,4,5,6}

class SequenceIterator implements Iterator<Integer>{
  Iterator<Integer> innerIt;
  Iterator<Iterator<Integer>> outerIt;
  
  public SequenceIterator(Iterator<Iterator<Integer>> iters){
    outerIt = iters;
    innerIt = iters.next();
  }
  
  @Override
  public boolean hasNext(){
    if(innerIt.hasNext()){
      return true;
    }
    if(outerIt.hasNext()){
      innerIt = outerIt.next();
    }else{
      return false;
    }
  }

  @Override 
  public T next(){
    if(hasNext()){
      return innerIt.next();
    }
    throw new NoSuchElementException;
  }
}


// EvenIterator (even index)
// go two steps everytime 
// {1,2,3,4,5} -> {1,3,5}
// 0, 1,2,3,4 



// version 1: 
static<T> Iterator<T> evenIterator(iterator<T> iterator){
  int current;
  
  return new Iterator<T>(){
    @Override 
    public boolean hasNext(){
      if(iterator.hasNext()){
        if(current % 2 == 0) return true;
        iterator.next();
        current++;
      }
      return false;
    }
    @Override 
    public T next(){
      if(hasNext()){
        return iterator.next();
      }
      throw new NoSuchElementException();
    }
  }
}


// version 2: 
static<T> Iterator<T> evenIterator(Iterator<T> iterator){
  return new Iterator<T>(){
    @Override
    public boolean hasNext(){
      return iterator.hasNext();
    }
    
    @Override
    public T next(){
      T result;
      if(hasNext()){
        result = iterator.next();
        if(iterator.hasNext()) iterator.next();
        return result;
      }
      throw new NoSuchElementException();
    }
  }
}


// Odd iterator (odd index)
// {1,2,3,4,5} - > {2,4}
// 0, 1,2,3,4

static<T> iterator<T> oddIterator(iterator<T> iterator){
  if(iterator.hasNext()){
    iterator.next();
  }
  return evenIterator(iterator);
}


// even value iterator 
// {1,2,3,5,7,8} -> {2,8}

// naive version:
class EvenIterator implements Iterator<Integer>{
  Iterator<Integer> iter;
  Integer cur;
  
  
  public EvenIterator(Iterator<Integer> iter){
    this.iter = iter;
  }
  
  public boolean hasNext(){
    while(iter.hasNext()){
      cur = iter.next();
      if(cur % 2 == 0) return true;
    }
    return false;
  }
  
  public Integer next(){
    if(hasNext()){
      return cur;
    }
    throw new NoSuchElementException();
  }
}

// what if someone crazy and evil calls hasNext() nonstop? 
// add a check 
class EvenIterator implements Iterator<Integer>{
  Iterator<Integer> iter;
  Integer cur;
  boolean check;
  
  
  public EvenIterator(Iterator<Integer> iter){
    this.iter = iter;
  }
  
  public boolean hasNext(){
    if(check){
      return true;
    }
    
    while(iter.hasNext()){
      cur = iter.next();
      if(cur % 2 == 0){
        check = true;
        return true;
      }
    }
    return false;
  }
  
  public Integer next(){
    if(hasNext()){
      check = false;
      return cur;
    }
    throw new NoSuchElementException();
  }
}



// zigzag iterator 

{
  {1,2,3}
  {10}
  {4,5}
  {6}
  
}

-> {1, 10, 4, 6, 2, 5, 3 }

static<T> Iterator<T> zigzagIterator(List<List<T>> lists){
  List<Iterator<T>> iteratorList = new ArrayList<Iterator<T>>();
  for(List<T> list : lists){
    iteratorList.add(list.iterator());
    
    Iterator<Iterator<T>> outer = cyclic(IteratorList);
    Iterator<T> inner = outer.next(); 
    
    return new Iterator<T>(){
      @Override
      public boolean hasNext(){
        for(int i = 0; i < lists.size(); i++){
          if(inner.hasNext()){
            return true;
          }
          inner = outer.next(); // cyclic alaways hasNext()
        }
        return false;
      }

      @Override 
      public T next(){
        if(hasNext()){
          T result = inner.next();
          inner = outer.next();
          return result;
        }
        throw new NoSuchElementException();
      }
    }
    
  };
}