【算法训练记录——Day18】

目标：
● 513.找树左下角的值
● 112.路径总和 113.路径总和ii
● 106.从中序与后序遍历序列构造二叉树 105.从前序与中序遍历序列构造二叉树

513.找树左下角的值

思路：层序遍历，每层保存第一个值

	int findBottomLeftValue(TreeNode* root) {
		int res = 0;
		if(root == nullptr) return res;
		queue<TreeNode*> que;
		que.push(root);
		while(!que.empty()) {
			int size = que.size();
			for(int i = 0; i < size; i++) {
				TreeNode* node = que.front();
				que.pop();
				if(i == 0) res = node->val;
				if(node->left != nullptr) que.push(node->left);
				if(node->right != nullptr) que.push(node->right);
			}
		}
		return res;
	}

递归：当深度+1的时候所遍历的就是第一个左节点。

	int maxDeep;
    int res;
    void order(TreeNode* node, int deep) {
		if(node == nullptr) return;
        if(deep > maxDeep) {
            res = node->val;
            maxDeep = deep;
        }
        order(node->left, deep + 1);
        order(node->right, deep + 1);
        return;
	}
	
	int findBottomLeftValue(TreeNode* root) {
		int deep = 0;
        maxDeep = -1;
        res = 0;
		order(root, deep);
        return res;
	}

112.路径总和

思路：循环终止条件：遍历到叶子节点，targetSum == sum 且 无子节点，返回true。

	bool order(TreeNode* node, const int targetSum, int sum) {
        bool res = false;
        if (node->left == nullptr && node->right == nullptr)
            return sum + node->val == targetSum ? true : false;
        if(node->left != nullptr)
            res = order(node->left, targetSum, sum + node->val);
        if(res == true) return res;
        if(node->right != nullptr)
            res = order(node->right, targetSum, sum + node->val);
        return res;
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root == nullptr) return false;
        return order(root, targetSum, 0);
    }

113.路径总和II

思路：每次递归传入的targetSum为targetSum-cur->val，并传入vector记录当前已走路线，当找到叶子节点时，若当前targetSum为0，则返回，没找到叶子节点则递归寻找左子树和右子树。
需要注意的是进入递归流程则表示当前的targetSum已经是处理过当前node->val后的值，因此递归哪个节点(next)则需要传入的targetSum为targetSum-next->val;
收获：递归想清楚结束和过程后并不困难，但是始终要清楚递归的参数是什么，在写这段代码时，traversal函数中进行递归时，我传入的targetSum和定义不符，导致结果半天出不来，下次还是要注意

	vector<vector<int>> res = {};
	
    void traversal(TreeNode* node, int targetSum, vector<int> v) {
        v.push_back(node->val);
        if(node->left == nullptr && node->right == nullptr && targetSum == 0) {
            res.push_back(v);
            return;
        }
        if(node->left != nullptr)
            traversal(node->left, targetSum - node->left->val, v);
        if(node->right != nullptr)
            traversal(node->right, targetSum - node->right->val, v);
        return;
    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        if(root == nullptr) return res;
        traversal(root, targetSum-root->val, {});
        return res;
    }

106.从中序与后序遍历序列构造二叉树

思路：想了一边构造的思路，根据后序遍历结果分割中序遍历数组，分左中序和右中序，再根据中序遍历结果分割后序数组，没想到怎么分割后序数组
看题解，了解了思路：
1. 递归过程，首先根据后序数组最后一位找到中序数组的分割点，分割点既是根节点，因此构造一个节点
2. 递归结束条件，当数组中元素只有一个时，结束，不为一个时，需要分割数组，继续递归，左子树为左中序数组结果，右子树同上。
3. 将中序数组分为左中序和右中序数组，此时，因为中序遍历数组和后序遍历数组大小一致，因此，将后序数组根据左中序大小和右中序大小分割开。
思路已经知道了，开始写一下

    TreeNode* traversal(vector<int>& inorder, vector<int>& postorder) {
        int size = inorder.size();
        int rootNum = postorder[size-1];
        int rootIndex = -1;
        for(int i = 0; i < size; i++) {
            if(inorder[i] == rootNum)
                rootIndex = i; 
        }

        TreeNode* root = new TreeNode(inorder[rootIndex]);
        if(size == 1) return root;

        // 分割左中序数组 [0, rootIndex)
        vector<int> leftInorder(inorder.begin(), inorder.begin() + rootIndex);
        int size2 = leftInorder.size();
        if(size2 > 0) {
            // 分割左后序 [0, size2)
            vector<int> leftPostorder(postorder.begin(), postorder.begin() + size2);
            root->left = traversal(leftInorder, leftPostorder);
        }

        // 分割右中序数组 [rootIndex+1, size())
        vector<int> rightInorder(inorder.begin() + rootIndex + 1, inorder.end());
        size2 = rightInorder.size();
        if(size2 > 0) {
            // 分割右后序 [end()-1 - size2, end()-1)
            vector<int> rightPostorder(postorder.end() - 1 - size2, postorder.end() - 1);
            // 分割右后序 [egin()+size2, end()-1)
            // vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end() - 1);
            root->right = traversal(rightInorder, rightPostorder);
        }
        return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if(inorder.size() == 0) return nullptr;
        return traversal(inorder, postorder);
    }

写完了这个再写一下 从前序与中序遍历序列构造二叉树
思路一样：首先确定递归过程，根据前序第一个节点分割中序数组为左中序和右中序，构建节点，根据左中序大小确定左前序数组起始位置和结束位置，开始递归。

	TreeNode* traversal(vector<int>& preorder, vector<int>& inorder) {
        int size = preorder.size();
        int rootNum = preorder[0];
        TreeNode* root = new TreeNode(rootNum);
        if(size == 1) return root;

        // 确定中序分割点
        int rootIndex = 0;
        for(; rootIndex < size; rootIndex++) {
            if(rootNum == inorder[rootIndex])
                break;
        }

        // 根据分割点分割左中序数组 (0, rootIndex)
        vector<int> leftInorder(inorder.begin(), inorder.begin() + rootIndex);
        int leftsize = leftInorder.size();
        if(leftsize > 0) {
            // 根据左中序数组大小确定左前序数组的结束位置
            vector<int> leftPreorder(preorder.begin() + 1, preorder.begin() + 1 + leftsize);
            root->left = traversal(leftPreorder, leftInorder);
        }
        
        // 根据分割点分割右中序数组 [rootIndex+1, size]
        vector<int> rightInorder(inorder.begin() + rootIndex + 1, inorder.end());
        if(size - leftsize > 1) {
            // 根据左前序数组的结束位置确定右前序数组的开始位置
            vector<int> rightPreorder(preorder.begin() + leftsize + 1, preorder.end());
            root->right = traversal(rightPreorder, rightInorder);
        }

        return root;
    }
    
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(preorder.size() == 0) return nullptr;
        return traversal(preorder, inorder);
    }

很好，思路清晰，一次就过。