这个问题在StackOverflow上已经被问过好几次了，但我还是再问一次，因为这个问题没有得到很好的回答或解释。
LeetCode上有一个问题，链接在这里：LeetCode Question Link
在那里你必须找到一个矩阵上的岛的数量（表示为“1”）。
这是我对这个问题的迭代深度优先搜索（DFS）解决方案：

public int numIslands(char[][] grid) {
    Stack<Integer> stack = new Stack<>();
    int counter = 0;
    int northBound = 0;
    int eastBound = grid[0].length - 1;
    int southBound = grid.length - 1;
    int westBound = 0;
    
    for (int i = 0; i < grid.length; i++) {
        for (int j = 0; j < grid[0].length; j++) {
            if (grid[i][j] == '1') {
                stack.add(i);
                stack.add(j);
                counter += 1;

                while (stack.size() > 0) {
                    int y = (int) stack.pop();
                    int x = (int) stack.pop();
                    grid[x][y] = '0';

                    if (x-1 >= northBound && grid[x-1][y] == '1') {
                        stack.push(x-1);
                        stack.push(y);
                    }

                    if (y+1 <= eastBound && grid[x][y+1] == '1') {
                        stack.push(x);
                        stack.push(y+1);
                    }

                    if (x+1 <= southBound && grid[x+1][y] == '1') {
                        stack.push(x+1);
                        stack.push(y);
                    }

                    if (y-1 >= westBound && grid[x][y-1] == '1') {
                        stack.push(x);
                        stack.push(y-1);
                    }
                }
            }
        }
    }

    return counter;
}

大多数人使用递归解决方案，但似乎普遍的共识是DFS解决这个问题的时间复杂度是O（m * n），其中m是矩阵中的行数，n是列数。
时间复杂度是O（（n）），所以我的算法是O（n）的。首先，我们可以看到两个外部for循环访问每个矩阵元素一次，所以这是O（m * n）。然而，在两个外部for循环访问的每个元素处，它可以访问1到m * n个其他元素之间的任何位置，这取决于具有1的相邻元素的数量。因此，复合时间复杂度可以是O((m*n) * (m*n))。
我的复杂性分析不正确的原因是什么？为什么其他人忽略了最内层while循环的复杂性？谢谢