引用、全局变量、递归、回溯

雪糕l

已于 2023-10-04 11:52:38 修改

阅读量119

点赞数

文章标签：算法 c++

于 2023-10-04 11:50:20 首次发布

本文链接：https://blog.csdn.net/despakiko/article/details/133547457

版权

在写二叉树的所有路径（力扣257）这道题目时，我最开始的想法是使用前序遍历，遇到叶字结点，就收集起来。

string path;
vector<string> res;
void traversal(TreeNode* node) {
    if(node == nullptr) return;
    path += to_string(node->val);
    if(node->left == nullptr && node->right == nullptr) {
        res.push_back(path);
        path = "";
        return;
    }
   
    path += "->";
    traversal(node->left);
    traversal(node->right);
}
vector<string> binaryTreePaths(TreeNode* root) {
    traversal(root);
    return res;
}

然后发现，每次path都变成空的话，就真的成了前序遍历了（结点根本没有重复）。

所以不能让path直接变成空，而是让path回退。比如[1,2,3,null,5]，收集完1->2->5之后，要回退的1，再进行对3的收集，而这个时候我需要1是存在路径当中的。所以问题来了，到底回退多少，这个就很折磨，没办法往后写了。

我在这里调试了很长时间，发现无论如何都无法匹配所有情况，因为如果path放在全局变量的话，它在所有的递归调用栈中，path都是一样的。所以如果我已经收集了一条路径，往回回溯的话，就需要path.resize()，把后面的收集过的节点去掉。但是后面收集过的结点，我也不知道到底收集了多少个，是哪一条路径。所以根本无法resize，回到我想到的path的那个状态。因此，直接将path放进参数，就完美得解决了这个问题！

vector<string> res;
void traversal(TreeNode* node,string path) {
  if(node == nullptr) return;
  path += to_string(node->val);
  if(node->left == nullptr && node->right == nullptr) {
    res.push_back(path);
    return;
  }
  path += "->";
  traversal(node->left,path);
  traversal(node->right,path);
}

这个样子，path就会在每一层保持他应该有的样子。

举例：[1,2,3,null,5]。在1那一层，path就是1->，2那一层，path就是1->2->，5那一层path就是1->2->5(后面不加->的原因是5是叶字结点，直接就收集了)，然后收集了1->2->5之后，往回走，回到2，path在2那一层是1->2->，发现2也走完了。就又回到1,path在1那一层是1->，因为左节点走完了，所以递归右节点，然后到3那一层, 1->3，因为3是叶字结点，所以收集了。

之后我看了代码随想录的代码。他的简单版本是这样子的：

    
    void traversal(TreeNode* cur, vector<int>& path, vector<string>& result) {
        path.push_back(cur->val); // 中，中为什么写在这里，因为最后一个节点也要加入到path中 
        // 这才到了叶子节点
        if (cur->left == NULL && cur->right == NULL) {
            string sPath;
            for (int i = 0; i < path.size() - 1; i++) {
                sPath += to_string(path[i]);
                sPath += "->";
            }
            sPath += to_string(path[path.size() - 1]);
            result.push_back(sPath);
            return;
        }
        if (cur->left) { // 左 
            traversal(cur->left, path, result);
            path.pop_back(); // 回溯
        }
        if (cur->right) { // 右
            traversal(cur->right, path, result);
            path.pop_back(); // 回溯
        }
    }

发现他不仅path在参数当中，并且还进行了回溯，按理说path在参数就不用进行回溯了呀，因为他在每一层的状态都是不一样的！

之后我发现，原来这个代码中，path虽然在参数里，但是加了引用&。这个引用一加，就相当于把path作为全局变量了，只有一份！谈论本题，他是先做保存数字，最后统一用->拼接，所以很好回溯！

代码随想录精简版代码：

 void traversal(TreeNode* cur, string path, vector<string>& result) {
        path += to_string(cur->val); // 中
        if (cur->left == NULL && cur->right == NULL) {
            result.push_back(path);
            return;
        }
        if (cur->left) traversal(cur->left, path + "->", result); // 左
        if (cur->right) traversal(cur->right, path + "->", result); // 右
    }

这个时候发现path就没有加引用了！

额外：如果加了引用，相当于只有一个全局变量path，每一层递归都会修改这一个path。不加引用，当前层的path就会一直保持，不会因为进入了下一层，就会被下一层改变path的代码而改变。所以不加引用，相应的内存消耗就会增加，加了引用，内存就会小一些。

下面2个是加了引用，上面2个是加了引用