LeetCode刷题笔记_20210925

1. 关于STL中的几个容器的api成员函数：

1.1 stack:

stack<int> s;

s.empty();
s.size();

s.top();

s.push(n);
s.pop();

1.2 queue:

queue<int> q;

q.empty();
q.size();

q.font();
q.back();

q.push();
q.pop();

stack 与 queue 的区别在于：

stack只能访问 栈顶元素（top），只能在栈顶单头位置插入或删除；

queue支持访问 队头、队尾元素（front、back），只能在队尾插入、队头删除（双端队列除外）。

其次，stack与queue的 共同点：

因为二者都只支持对头尾元素的操作，所以在stack和queue上没有迭代器，也没有与迭代器有关的操作（如insert、erase等）

1.3 set：

set<int> s;

迭代器： 
s.begin(); end(); cbegin(); cend(); rbegin(); rend(); crbegin(); crend();

s.empty();
s.size();


s.insert(n);
s.insert(it, n);
s.insert(s2.begin(), s2.end());

s.erase(it);
s.erase(n);

s.clear();


s.find(n);		//返回iter。
				//!!!切记：迭代器不能与NULL直接比较，迭代器不是指针，迭代器是封装了指针的类
s.count(n);

1.4 vector的at 与 []下标操作的真正区别：

纠正一个误区：
at()检查数组越界访问，不是发生在编译时，编译可以正常通过，而是发生在 运行时。

at与[]下标访问 的区别在于：
如果发生了数组越界访问，即使是在运行时，[]也不会报错，程序还是可以继续运行下去，只有等到导致程序真的出错时才会停下来；
而at()在运行时如果发现有越界访问会立马报错停止。

例如：

int main() {
	vector<int> v;
	v.resize(3);
	v[5];			//运行到这里不会报错
	int a = v[5];	//正常
	cout << a;		//正常！
	cout << v[5];	//报错！

	v.at(5);		//立刻报错，不论你是否有用到它的返回值
}

2. 记忆化递归：

相关题目：《剑指 Offer 10- I. 斐波那契数列》
https://leetcode-cn.com/problems/fei-bo-na-qi-shu-lie-lcof/

“记忆化递归”是 递归法的优化版本。

原理：
在递归法的基础上，新建一个长度为n的数组，用于在递归时存储f(0)到f(n)的数值，
当重复遇到某数字时则直接取用，避免了重复的递归计算。

缺点：
记忆化存储需要使用 O(N) 的额外空间。

单纯的暴力递归当遇到超过 四五十的数字时就会计算超时，递归深度太大，借助数组优化效果明显。

3. 二分查找：

相关题目：《剑指 Offer 11. 旋转数组的最小数字》
https://leetcode-cn.com/problems/xuan-zhuan-shu-zu-de-zui-xiao-shu-zi-lcof/

3.1 要使用二分查找，数据需满足如下两条要求：

（1）顺序存储：
必须是数组，不能是链表，因为需要支持下标查找，不然连续那样的二分查找还不如O(N)遍历一次更快

（2）元素有序：
任取一个关键字的值，就能确定所寻找的关键字是在它前面还是后面

3.2 二分查找的时间复杂度：

O(logN)

3.3 取mid中间点的写法：

提倡写法：

int mid = left + (right - left) / 2;	
// (起点 + 差值/2)

不提倡写法：

int mid = (left + right) / 2;		

原因：
当left、right的值很大时，可能会造成int溢出。

3.4 vector中取下标操作：

使用迭代器begin、end时会比较麻烦，因为需要*解引用得到值；取下标的写法：0， size - 1（首、尾）：

int left = 0;
int right = nums.size() - 1;

3.5 编译报错：reference to ‘array’ is ambiguous

ambigous直译过来是“有歧义的”，
这样的错误是指程序中自定义的 array 变量与标准库中的变量名字重复了，改个变量名即可解决。

4. string.push_back 只能用于插入一个字符char型，string.append用于插入字符串：

相关题目：《剑指 Offer 05. 替换空格》
https://leetcode-cn.com/problems/ti-huan-kong-ge-lcof/solution/

举例：

string result;
result.reserve(s.size()*3);      //给string预留出足够的内存空间，避免重复申请搬移内存
for(int i = 0; i < s.size(); i++) {
    if(s[i] == ' ')    
        result.append("%20");    //string.append用于加入字符串
    else 
        result.push_back(s[i]);  //string.push_back只能插入char型
}

5. ListNode* head = nullptr;中*head指向的是0地址：

相关题目：《剑指 Offer 25. 合并两个排序的链表 这也许是最简单的解法》
https://leetcode-cn.com/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof/

错误写法：

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    //ListNode* head = new ListNode(0);
    ListNode* head = nullptr;		//*head指针指向0地址： 0x0
    ListNode* cur = head;

    while (l1 && l2) {
        if (l1->val < l2->val) {
            cur->next = l1;		//这里就会报错，
            					//相当于在访问 nullptr->next;  这肯定不对
            l1 = l1->next;
        } else {
            cur->next = l2;
            l2 = l2->next;
        }
        cur = cur->next;
    }  
    return head->next;
}

正确写法：

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    ListNode* head = new ListNode(0);
    ListNode* cur = head;			//cur指针指向一块【堆 内存】

	或者：
	ListNode temp(0);				//定义一个局部变量
    ListNode* head = &temp;
    ListNode* cur = head;			//cur指针指向一块【栈 内存】
}

总结一下：

ListNode* head = nullptr; 怎么理解？
指针变量是真实存在的，*head 是一个局部变量，但是将其赋值为空指针时，它指向了0x0地址，再对其进行操作就错了。