列D1中的迭代器2D矢量

Question

如果我想通过像这样的矢量，而不是逐行逐列地浏览一下，我需要做什么改变？

vector<vector<bool>> vvi(nLin, vector<bool>(nCol, false)); 

vector< vector<bool> >::iterator row; 
vector<bool>::iterator col; 

    for (row = vvi.begin(); row != vvi.end(); row++) { 
     for (col = row->begin(); col != row->end(); col++) { 
      // do stuff ... 
     } 
    } 

感谢

Answer 1

如果你想使用vector<vector<T>>这一点，那么你只能在遍历一个订单。请注意，这不是逐行，也不是逐列，但实际上是逐个矢量。每个子矢量的存储分配完全独立于另一个矢量，并且甚至可以具有不同的长度，因此很难将其称为“行”。

如果你想要一个像矩阵一样的（一般张量）存储，你应该考虑使用一些提供（STL不）的库，例如OpenCV，或者把一个连续的vector包装到你自己的类中。做索引。

struct Matrix { 
    std::vector<bool> storage; 
    int ncols; 
    Matrix(int nrows, int ncols) : storage(nrows * ncols), ncols(ncols) {} 
    bool& operator[](int row, int col) { 
     return storage[row * ncols + col]; 
    } 
}; 

然后你可以重复使用普通for循环或编写自己的迭代器。

如果这是太多的工作，你可以用vector<vector<bool>>坚持，但使用operator[]代替迭代器：

for (int col = 0; col < nCols; ++col) { 
    for (int row = 0; row < nRows; ++row) { 
     bool& el = vvi[row][col]; 
     // do stuff on el 
    } 
} 

Answer 2

不要使用迭代器：

int row = 0;   // V You could also use ncol below, if you know it wont change. 
for (int col = 0; col < vvi.at(row).size(); col++) { 
    for (row = 0; row < vvi.size(); row++) { 
     // get current value by vvi.at(row).at(col) 
    } 
} 

这是不安全的，虽然，如果你这样做不知道你的每一行都是相同的大小。这就是为什么我们使用.at(或者你可以做你自己的边界检查。

Answer 3

既然你知道的列数，NCOL，你就可以生产迭代器是这样的：

for (size_t colNo = 0; colNo < nCol; ++colNo) { 
    for (const auto& row: vvi) { 
     auto it = row.begin() + colNo; 
     // do stuff 
    } 
} 

如果你实际上并不需要迭代器：

for (size_t colNo = 0; colNo < nCol; ++colNo) { 
    for (const auto& row: vvi) { 
     bool colVal = row.at(colNo); 
     // do stuff 
    } 
} 

Answer 4

我有一个答案写在Java和它需要O（行数）空间：

public static void main(String[] args) { 
    List<List<Integer>> list = new ArrayList<>(); 
    list.add(Arrays.asList(1,5,8)); 
    list.add(Arrays.asList(2)); 
    list.add(Arrays.asList(3,6,9,11,13)); 
    list.add(Arrays.asList(4,7,10,12)); 

    LinkedList<Iterator<Integer>> queue = new LinkedList<>(); 
    Iterator<List<Integer>> iterator = list.iterator(); 
    while (iterator.hasNext()) { 
     queue.add(iterator.next().iterator()); 
    } 

    while (!queue.isEmpty() && queue.peekFirst().hasNext()) { 
     System.out.println(queue.peekFirst().next()); 
     Iterator<Integer> garbage = queue.removeFirst(); 
     if (garbage.hasNext()) { 
      queue.add(garbage); 
     } 
    } 
}