# Flatten 2D Vector

Design and implement an iterator to flatten a 2d vector. It should support the following operations:`next`and`hasNext`.

**Example:**

```
Vector2D iterator = new Vector2D([[1,2],[3],[4]]);

iterator.next(); // return 1
iterator.next(); // return 2
iterator.next(); // return 3
iterator.hasNext(); // return true
iterator.hasNext(); // return true
iterator.next(); // return 4
iterator.hasNext(); // return false
```

**Notes:**

1. Please remember to **RESET** your class variables declared in Vector2D, as static/class variables are **persisted across multiple test cases** . Please see [here](https://leetcode.com/faq/) for more details.
2. You may assume that `next()`call will always be valid, that is, there will be at least a next element in the 2d vector when

   `next()` is called.

**Follow up:**

As an added challenge, try to code it using only [iterators in C++](http://www.cplusplus.com/reference/iterator/iterator/) or [iterators in Java](http://docs.oracle.com/javase/7/docs/api/java/util/Iterator.html).

## Solution

Using Index i, j - (**72 ms, 11.78%)**

```java
class Vector2D {

    private int i, j;
    private int[][] v;
    public Vector2D(int[][] v) {
        i = 0;
        j = 0;
        this.v = v;
    }

    public int next() {
        int n = 0;
        if (i < v.length && j >= v[i].length) {
            while (i < v.length) {
                i++;
                if (j < v[i].length) {
                    break;
                }
            }
        }
        n = v[i][j];
        if (j == v[i].length - 1) {
            j = 0;
            i++;
        } else {
            j++;
        }
        return n;
    }

    public boolean hasNext() {
        int ti = i;
        int tj = j;
        if (ti < v.length && tj < v[ti].length) {
            return true;
        } else if (ti < v.length) {
            while (ti < v.length) {
                if (tj < v[ti].length) {
                    return true;
                }
                ti++;
            }
        }
        return false;
    }
}

/**
 * Your Vector2D object will be instantiated and called as such:
 * Vector2D obj = new Vector2D(v);
 * int param_1 = obj.next();
 * boolean param_2 = obj.hasNext();
 */
```

Iterator

```java
public class Vector2D {

    private Iterator<List<Integer>> i;
    private Iterator<Integer> j;

    public Vector2D(List<List<Integer>> vec2d) {
        i = vec2d.iterator();
    }

    public int next() {
        hasNext();
        return j.next();
    }

    public boolean hasNext() {
        while ((j == null || !j.hasNext()) && i.hasNext())
            j = i.next().iterator();
        return j != null && j.hasNext();
    }
}
```

Another

```java
public class Vector2D {
    int indexList, indexEle;
    List<List<Integer>> vec; 

    public Vector2D(List<List<Integer>> vec2d) {
        indexList = 0;
        indexEle = 0;
        vec = vec2d;
    }

    public int next() {
        return vec.get(indexList).get(indexEle++);
    }

    public boolean hasNext() {
        while(indexList < vec.size()){
            if(indexEle < vec.get(indexList).size())
                return true;
            else{
                indexList++;
                indexEle = 0;
            }
        }
        return false;
    }
}
```