4.力扣

这一题的难度比较大，运用到了回溯算法

思路：

我们可以通过一个数组来记录数字与字母之间的映射关系，然后利用回溯算法（递归）就解决像这种组合问题，下面通过这题来大概讲解一下回溯：

 这个很像二叉树的遍历，但又复杂一点，这个可以看成多叉树的遍历方式。我们可以通过每一层的递归来达到一个组合的效果。

代码实现：

class Solution {//映射数组string numstr[10] = {"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
public://递归子函数void combine(string& digits,int i,vector& vcombine,string retstr){if(i == digits.size()){vcombine.push_back(retstr);return;}//找到对应的字母int num = digits[i]- '0';string str = numstr[num];//遍历串中的所有字符，然后进入下一层for(auto ch:str){combine(digits,i+1,vcombine,retstr+ch);}}vector letterCombinations(string digits) {vector vcombine;if(digits.empty()){return vcombine;}int i = 0;string retstr;//用来每次加，然后最后加到vcombine中 //递归combine(digits,i,vcombine,retstr);return vcombine;}
};

下面通过画递归展开图再来看看其中的细节：

2.vector深度剖析及模拟实现

使用memcpy拷贝问题

1. memcpy是内存的二进制格式拷贝，将一段内存空间中内容原封不动的拷贝到另外一段内存空间中 2. 如果拷贝的是自定义类型的元素，memcpy既高效又不会出错，但如果拷贝的是自定义类型元素，并且自定义类型元素中涉及到资源管理时，就会出错，因为memcpy的拷贝实际是浅拷贝。

这个和之前讲拷贝构造的时候很像，都是浅拷贝导致的问题。 可能会引起内存泄漏甚至程序崩溃。

动态二维数组理解

在前面就已经看过了二维数组的题了，这里不过多介绍，还是介绍一下memcpy也会使内存崩溃的结果：

 要解决这个问题，我们还是要进行深拷贝，这是下面的reserve的模拟实现代码来解决这个问题：

 我们可以通过这个一个对象赋值的方式来进行深拷贝

模拟实现vector：

templateclass vector{public:// Vector的迭代器是一个原生指针typedef T* iterator;typedef const T* const_iterator;iterator begin(){return _start;}iterator end(){return _end;}const_iterator cbegin(){return _start;}const_iterator cend() const{return _end;}// construct and destroyvector():_start(nullptr),_end(nullptr),_endOfStorage(nullptr){}vector(int n, const T& value = T()):_start(nullptr), _end(nullptr), _endOfStorage(nullptr){reserve(n);for (int i = 0; i < n; ++i){push_back(value);}}templatevector(InputIterator first, InputIterator last):_start(nullptr), _end(nullptr), _endOfStorage(nullptr){while (first != last){push_back(*first);++first;}}vector(const vector& v):_start(nullptr), _end(nullptr), _endOfStorage(nullptr){//找个工具人vector tmp(v._start, v._end);swap(tmp);}vector& operator= (vector v){swap(v);return *this;}~vector(){delete[] _start;_start = _end = _endOfStorage = nullptr;}// capacitysize_t size() const{return _end - _start;}size_t capacity() const{return _endOfStorage - _start;}void reserve(size_t n){//坚持不缩容if (n > capacity()){//开辟新的空间，然后赋值过去T* tmp = new T[n];size_t oldsize = size();if (_start){for (size_t i = 0; i < oldsize; ++i){tmp[i] = _start[i];}delete[]_start;}_start = tmp;_end = _start + oldsize;_endOfStorage = _start + n;}}void resize(size_t n, const T& value = T()){//要扩容if (n > capacity()){int newcapacity = capacity() == 0 ? 4 : 2 * capacity();reserve(newcapacity);}if (n > size()){while (_end != _start + n){push_back(value);}}else{_end = _start + n;}}///access///T& operator[](size_t pos){assert(pos < size());return _start[pos];}const T& operator[](size_t pos)const{assert(pos < size());return _start[pos];}///modify/void push_back(const T& x){if (size() == capacity()){int newcapacity = capacity() == 0 ? 4 : 2 * capacity();reserve(newcapacity);}*_end = x;++_end;}void pop_back(){assert(_end > _start);--_end;}void swap(vector& v){std::swap(_start, v._start);std::swap(_end, v._end);std::swap(_endOfStorage, v._endOfStorage);}iterator insert(iterator pos, const T& x){assert(_start <= pos);assert(_end > pos);//判断增容int distance = pos - _start;if (_end == _endOfStorage){int newcapacity = capacity() == 0 ? 4 : 2 * capacity();reserve(newcapacity);//这里的扩容不处理会导致迭代器失效pos = _start + distance;}//挪动数据，插入auto end = _end -1;while (end >= pos){*(end+1) = *end;--end;}*pos = x;++_end;return pos;}iterator erase(iterator pos){assert(pos >= _start);assert(pos < _end);//挪动数据iterator  ret = pos + 1;while (ret < _end){*(ret - 1) = *ret;++ret;}--_end;return pos;}private:iterator _start; // 指向数据块的开始iterator _end; // 指向有效数据的尾iterator _endOfStorage; // 指向存储容量的尾};

其中实现过程中最容易错误的就是insert以及erase扩容问题，这是最容易出错的。

扩容是防止浅拷贝，所有把利用赋值来实现深拷贝。insert以及erase要注意更新迭代器，防止迭代器失效。