4.补充题：手撕快速排序

给你一个整数数组 nums，请你将该数组升序排列。

你必须在 不使用任何内置函数 的情况下解决问题，时间复杂度为 O(nlog(n))，并且空间复杂度尽可能小。

示例 1：

输入：nums = [5,2,3,1]
输出：[1,2,3,5]

思路详解：快速排序是一种分治的思想，先选一个基准元素，将所有大于基准元素的元素放到基准元素的右边，所有小于基准元素的放到左边，然后数组就被基准元素拆成两个数组，再对被拆分的数组进行快速排序，重复上面的步骤直到左右指针重合。如果不理解可以看以下图片

这是第一次快速排序，下次快速排序时重新选择基准元素，再以此法排序

代码详解：

class Solution {
public:
    void quicksort(vector<int>& v, int start, int end) {
        if (start >= end) {
            return;
        }
        int temp = v[start]; // 区域内的第一个元素定位基准值
        int i = start - 1, j = end + 1;//设置左边界和右边界
        int index = start;//将第一个元素作为索引
        while (index < j) {
            if (v[index] == temp) {
                index++;
            } else if (v[index] > temp) {
                swap(v[--j], v[index]);
            } else {
                swap(v[++i], v[index++]);//开始交换，如果待排元素小于基准元素就放到基准元素的左边，否则就放到右边
            }
        }//第一次分割完数组后，重新排序左边和右边的数组
        quicksort(v, start, i);//排序左边的数组
        quicksort(v, j, end);//排序右边的数组
    }
    vector<int> sortArray(vector<int>& nums) {
        quicksort(nums,0,nums.size()-1);//调用函数即可
        return nums;
    }
};

面经

 1. 什么是c++中的lamabda表达式，有什么作用，如何使用lamabda表达式

lambda表达式是一个匿名内联函数包括引用捕获和值（只读）捕获

作用是在函数内部定义一个函数，可以帮助函数访问作用域之外的其他变量

全局变量不需要捕获

[捕获列表] 函数参数  返回值 {函数体}

没有参数可以不写（），返回值也可以不写，编译器会自动推导返回值类型，但是当基于列表返回时不能推导如：return {1，2，3}

//此时应该写为：
auto f1=[]()->vector<int>//返回列表不能捕获
{
    return {1,2,3};
}

lambda表达式存在捕获列表，捕获列表有以下几种：

[]不捕获任何变量

[&]捕获外部作用域的所有变量，按引用捕获

[=]捕获外部作用域的所有变量，按照值捕获，拷贝过来的副本在函数体内只读

[=,&a]按值捕获外部作用域中所有变量，按引用捕获a

[变量名]按值捕获对应变量，不捕获其他变量

[this]捕获当前类中的this指针，让lambda表达式拥有和当前类成员函数同样的访问权限

引用捕获的可以修改，值捕获不能修改只读

代码示例：捕获局部变量

int main() {
	int a = 10, b = 20;
	auto f1 = [] {return a; };//未能捕获不能用
	auto f2 = [&] {return a++; };
	auto f3 = [=] {return a + b; };
	auto f4 = [=] {return a++; };//值捕获不能修改
	auto f5 = [a] {return a + b; };//没有捕获b不能使用
	auto f6 = [a, &b] {return a + (b++); };
	auto f7 = [=, &b] {return a + (b++); };
 
	return 0;
}

代码示例：在类中捕获

class Test
{
public:
	void output(int x, int y)
	{
		auto x1 = [] {return num; };//由于类要产生很多对象，编译器无法知道捕获的是哪一个类的对象所以直接使用this就可以例如x4
		auto x2 = [=] {return num + x + y; };
		auto x3 = [&] {return num + x + y; };
		auto x4 = [this] {return num; };
		auto x5 = [this] {return num + x + y; };//只捕获this是捕获不到参数变量的 
		auto x6 = [this,x,y] {return num + x + y; };
		auto x7 = [this] {return num++; };
	}
	int num = 100;
};