讨论/意见反馈/反馈|无法调试/

描述

调试中,步进时到next函数的while
提示“获取内容失败”
随后调试界面恢复到调试前状态
此后再次点击调试,提示“请先结束当前调试”

具体链接

使用设备:PC

用于调试的代码

/**
 * // This is the interface that allows for creating nested lists.
 * // You should not implement it, or speculate about its implementation
 * class NestedInteger {
 *   public:
 *     // Return true if this NestedInteger holds a single integer, rather than a nested list.
 *     bool isInteger() const;
 *
 *     // Return the single integer that this NestedInteger holds, if it holds a single integer
 *     // The result is undefined if this NestedInteger holds a nested list
 *     int getInteger() const;
 *
 *     // Return the nested list that this NestedInteger holds, if it holds a nested list
 *     // The result is undefined if this NestedInteger holds a single integer
 *     const vector<NestedInteger> &getList() const;
 * };
 */

class NestedIterator {
public:
    NestedIterator(vector<NestedInteger> &nestedList) {
        nowIndex = 0, nowSize = nestedList.size();
        nowList = nestedList;
    }
    
    int next() {
        // 当前元素
        NestedInteger elem = nowList[nowIndex];
        // 是数字就直接输出,不是的话需要加入栈,并改变当前层
        if(elem.isInteger()){
            nowIndex++;
        }else{
            // 如果是多层list嵌套就需要循环
            while(elem.isInteger() != true){
                vector<NestedInteger> newList = elem.getList();
                // 保存现场,准备进入下一层
                nestedStack.push(newList);
                // 进入下一层,更改list
                elem = newList[0];
                // 这里的后移是为了创造返回点
                nowIndex++;
                index.push(nowIndex);
                nowIndex = 0;
            }
        }
        return elem.getInteger();
    }
    
    bool hasNext() {
        // 只有最外层
        if(nestedStack.empty()){
            if(nowIndex >= nowSize) {
                return false;
            }
        // 还有其它层
        }else{
            // 如果一层只有一个元素,可能存在需要重复弹出层的情况,需要循环
            while(nowIndex >= nowSize){
                nowIndex = index.top();
                index.pop();
                nestedStack.pop();
                nowSize = nestedStack.top().size();
            }
        }
        return true;
    }
private:
    int nowIndex, nowSize;
    vector<NestedInteger> nowList;
    stack<vector<NestedInteger>> nestedStack;
    stack<int> index;
};

/**
 * Your NestedIterator object will be instantiated and called as such:
 * NestedIterator i(nestedList);
 * while (i.hasNext()) cout << i.next();
 */

由于无法调试,不保证代码正确性
但没有报错,而是直接弹出“获取内容失败”

共 1 个回复

我测试了下你的代码,显示是超出时间限制。hasNext() 函数对于用例[[1,1],2,[1,1]]始终是true
请问下是否使用了调试器Beta这个功能,我不确定是否因为代码本身有bug导致调试器调试失败。

感觉有一些问题:

  1. nowIndex, nowSize 表示的是当前栈函数的索引和对应vector元素个数,那么进入下一层,nowSize是否需要变化,nowIndex 是否需要更新
  2. 如何处理空列表问题。

我按照你的写了一个可以通过的版本,你可以提交一下,然后测试下能否正常调试...
另外建议看一下这道题C++的题解,其实存入迭代器就可以了。


class NestedIterator {
private:
    // int nowIndex, nowSize; 不需要,因为通过index和nestedStack可以推导出nowIndex和nowSize
    // vector<NestedInteger> nowList; 不需要,因为在nestedStack 中
    stack<vector<NestedInteger>> nestedStack; // 存入的是每次递归中的原始嵌套列表
    stack<int> index; // 存入的是状态下遍历的数组下标
public:
    NestedIterator(vector<NestedInteger> &nestedList) {
        // nowIndex = 0, nowSize = nestedList.size();
        // nowList = nestedList;
        index.push(0); // 当前需要遍历的下标是 0
        nestedStack.push(nestedList); // 当前需要遍历的列表是输入列表
    }
    
    int next() {
        // 由于每次调用next() 都会提前调用hasNext()
        // 逻辑在hasNex()中完成
        auto nowList = nestedStack.top();
        nestedStack.pop();
        index.pop();
        return nowList[0].getInteger();

    }
    
    bool hasNext() {
        while (!nestedStack.empty()){
            auto nestedList = nestedStack.top();
            int nowIndex = index.top();
            int nowSize = nestedList.size();
            index.pop();
            if (nowIndex == nowSize){
                // 当前遍历位置在列表尾部,因此stack中的列表被使用完,弹出
                nestedStack.pop();
                continue; 
            }
            // 否则移动遍历的位置,并找到对应元素
            auto item = nestedList[nowIndex];
            ++nowIndex;
            if (nowIndex == nowSize){
                // 移动后在列表尾部
                nestedStack.pop();
            }
            else{
                // 加入新的位置
                index.push(nowIndex);
            }
            // 判断新元素是否为列表
            if (item.isInteger()){
                // item 是一个 NestedInteger
                // 那么stack中应该存入 vector<NesetedInteger> {item}
                // index 存入 0
                // 返回 True
                nestedStack.push({item});
                index.push(0);
                return true;
            }
            else{
                nestedStack.push(item.getList());
                index.push(0);
            }
        }
        return false;
    }
};