lambda 自调用递归

从前序与中序遍历序列构造二叉树

官方解析实在是记不住，翻别人的题解发现了一个有意思的写法

class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        auto dfs = [](auto&& dfs, auto&& lP, auto&& lI, auto&& rI) {
            if (lI == rI) return (TreeNode*)nullptr;
            auto loc = find(lI, rI, *lP);
            return new TreeNode(*lP, dfs(dfs, lP + 1, lI, loc),
                                     dfs(dfs, lP + (loc - lI) + 1, loc + 1, rI));
        };
        return dfs(dfs, preorder.cbegin(), inorder.cbegin(), inorder.cend());
    }
};

看起来简单有意思，但是这个 auto dfs = [](auto&& dfs, 是什么意思呢？

lambda 自调用

C++11，借助std::function

#include <iostream>
#include <functional>
int main(int argc, char* argv[])
{
	std::function<int(int)> fib = [&fib](int n) { return n < 2 ? n : fib(n - 1) + fib(n - 2); };
	std::cout << fib(5);
	return 0;
}

借助 std::function 代码修改如下：

class Solution {
    public:
        TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
            function<TreeNode* (vector<int>::const_iterator, vector<int>::const_iterator, vector<int>::const_iterator)> 
                dfs = [&dfs]( auto&& lP, auto&& lI, auto&& rI) {
                if (lI == rI) return (TreeNode*)nullptr;
                auto loc = find(lI, rI, *lP);
                return new TreeNode(*lP, dfs( lP + 1, lI, loc),
                    dfs(lP + (loc - lI) + 1, loc + 1, rI));
            };
            return dfs( preorder.cbegin(), inorder.cbegin(), inorder.cend());
        }
    };

这个function 是个啥？没用过

C++11 std::function 基础用法

std::function是C++11标准库中提供的一种可调用对象的通用类型，它可以存储任意可调用对象，如函数指针，函数对象，成员函数指针和lambda表达式。std::function类模板是一个类似于函数指针的类型，但它是可以处理任意可调用对象的，并且可以检查调用对象是否为空。

需要头文件： functional

基本用法：

std::function<return_type(parameter_types)> var_name;

std::function对象可以像普通函数一样调用，并且可以使用bool类型的运算符来检查调用对象是否为空。

std::function<int(int, int)> f;
if (f)
    std::cout << f(1, 2) << std::endl;
else
    std::cout << "f is empty" << std::endl;

std::function可以存储智能指针，避免内存泄漏：

std::function<int(int, int)> add = std::make_shared<int(*)(int, int)>([](int a, int b) { return a + b; });

这段代码定义了一个变量add，它是一个std::function类型，这种类型可以存储一个可调用的函数（可以是函数指针、函数对象、lambda表达式等）。该函数的签名为int(int, int)，即返回值类型为int,接受两个int类型参数。变量add被赋值为一个指向匿名函数的指针。这个匿名函数接受两个int类型参数，并返回它们的和。使用std::make_shared<int(*)(int, int)>来创建该函数的共享指针

存储成员函数指针

调用类的成员函数：

class A {
public:
    int add(int a, int b) { return a + b; }
};
std::function<int(A&, int, int)> add = &A::add;
A a;
std::cout << add(a, 3, 4) << std::endl;

补充：iterator与const_iterator及const iterator区别

如果你传递过来一个const类型的容器，那么只能用const_iterator来遍历。

void Method(const vector<int> vInt)
{
  vector<int>::const_iterator iter;
}

1.iterator,const_iterator作用：遍历容器内的元素，并访问这些元素的值。iterator可以改元素值,但const_iterator不可改。跟C的指针有点像
(容器均可以++iter,而vector还可以iter-n, iter+n,n为一整型,iter1-iter2:结果是difference_type类型，表两元素的距离.)

2.const_iterator 对象可以用于const vector 或非 const vector,它自身的值可以改(可以指向其他元素),但不能改写其指向的元素值.

3.const iterator与const_iterator是不一样的：声明一个 const iterator时，必须初始化它。一旦被初始化后，就不能改变它的值,它一旦被初始化后,只能用它来

改它指的元素,不能使它指向其他元素。(因此const iterator几乎没什么用途)

例 vector<int> nums(10); // nums is nonconst
     const vector<int>::iterator cit = nums.begin();
     *cit = 1;               // ok: cit can change its underlying element
     ++cit;                  // error: can't change the value of cit

例：读入一段文本到 vector 对象，每个单词存储为 vector 中的一个元素。把 vector 对象中每个单词转化为小写字母。输出 vector 对象中转化后的元素，每八个单词为一行输出

                                                                                  --摘自C++primer 3.14

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

106. 从中序与后序遍历序列构造二叉树 - 力扣（LeetCode）

/**
 * 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:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        function<TreeNode* (vector<int>::const_reverse_iterator, vector<int>::const_iterator, vector<int>::const_iterator)> 
                dfs = [&dfs]( auto&& lP, auto&& lI, auto&& rI) {
                if (lI == rI) return (TreeNode*)nullptr;
                auto loc = find(lI, rI, *lP);
                return new TreeNode(*lP, dfs( lP + (rI - loc), lI, loc),
                    dfs(lP + 1, loc + 1, rI));
            };
            return dfs( postorder.crbegin(), inorder.cbegin(), inorder.cend());
    }
};

注意两点： 1，vector<int>::const_reverse_iterator, postorder.crbegin() ，逆序迭代器

2，new TreeNode(*lP, dfs( lP + (rI - loc), lI, loc),
dfs(lP + 1, loc + 1, rI)); 计算移动位置与前序不同

参考：C++ 实现lambda递归调用（C++11 - C++23）_c++ lamda 递归-CSDN博客

C++11 std::function 基础用法_std::function用法-CSDN博客

iterator与const_iterator及const iterator区别