递归回溯算法小结

以257. 二叉树的所有路径为例
之前忽略或者不成系统的点：
一个递归，一个回溯
递归是前序遍历，先处理本个节点的逻辑，然后处理左右节点
处理左右节点的过程中，递归和回溯要点在于要一一对应
这个对应关系是，我需要判断下一层可能发生的逻辑（比如它会将我的path添加了一个元素），然后在回溯里面做出处理（pop）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<string> result;
    void trans2Res(vector<int>& path) {
        string str;
        for (int i = 0; i < path.size() - 1; i++) {
            str = str+to_string(path[i]) + "->";            
        }
        str+=(to_string(path.back()));
        result.push_back(str);
    }
    void traversal(TreeNode* root, vector<int>& path) {
        //前序遍历
        path.push_back(root->val);//中        
        if (root->left == NULL && root->right == NULL) {
            trans2Res(path);
            return;
        }
        if (root->left) {
            traversal(root->left, path);//左
            path.pop_back();
        }
        if (root->right) {
            traversal(root->right, path);//右
            path.pop_back();
        }      
        
        return;
    }

	vector<string> binaryTreePaths(TreeNode* root) {
        if(root==NULL){
            return {};
        }
        vector<int> path;
        traversal(root, path);
        return result;
	}
};

以及非递归写法

    int sumOfLeftLeaves(TreeNode* root) {
        stack<TreeNode*> stk;
        if (root) stk.push(root);
        int sum = 0;
        while (!stk.empty()) {
            TreeNode* node = stk.top();
            stk.pop();
            //右
            if (node->right) stk.push(node->right);
            //左
            if(node->left) stk.push(node->left);
            //中
            if (node->left != NULL && node->left->left == NULL && node->left->right == NULL) {
                sum += node->left->val;
            }
        }
        return sum;
    }

树的三种遍历的万能写法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
 int sumOfLeftLeaves(TreeNode* root) {
        stack<TreeNode*> stk;
        if (root) stk.push(root);
        int sum = 0;
        while (!stk.empty()) {
            TreeNode* node = stk.top();
            stk.pop();
            if (node != NULL) {
				//右
				if (node->right) stk.push(node->right);
				//左
				if (node->left) stk.push(node->left);
                //中
                stk.push(node);
                stk.push(NULL);
            }
            else {
				//中
				TreeNode* node = stk.top();
				stk.pop();
				if (node->left != NULL && node->left->left == NULL && node->left->right == NULL) {
					sum += node->left->val;
				}
            }
        }
        return sum;
    }
};

另外记录一下对于递归的设计：

• 「如果需要遍历整颗树，递归函数就不能有返回值。如果需要遍历某一条固定路线，递归函数就一定要有返回值！」
• 只有寻找某一条边（或者一个节点）的时候，递归函数会有bool类型的返回值。