面试题c/c++ --STL 算法与数据结构

1.6 STL

模板

模板底层实现：编译器会对函数模板进行两次编译，在声明的地方对模板代码本身进行编译，在调用的地方对参数替换后的代码进行编译。

模板传参分析

模板重载

vector

是动态空间，随着元素的加入，它的内部机制会自行扩充空间以容纳新元素。vector 的数据结构其实就是三个迭代器构成的，一个指向目前使用的空间头，一个指向目前使用空间尾，一个指向目前可用的空间尾。当有新元素插入时，如果目前容量够用则直接插入；若不够则容量扩充至两倍，依次类推。扩充的过程是重新申请一块连续空间，将原有数据拷贝到新空间，再释放原有空间，扩充后原有的迭代器会

失效。

remove() 的实现原理：在遍历容器中的元素时，一旦遇到目标元素，就做上标记，然后继续遍历，直到找到一个非目标元素，即用此元素将最先做标记的位置覆盖掉，同时将此非目标元素所在的位置也做上标记，等待找到新的非目标元素将其覆盖。remove() 不会改变其容量大小，而 erase() 可以改变其容量大小，通常将 remove() 返回的迭代器传入 erase() 中清除后续无用元素。

注意事项：

● 插入和删除元素后，如果由于内存重分配则会导致迭代器全部失效；没有重分配则插入和删除之后的迭代器失效。

● 清空 vector 数据时，如果保存的数据项是指针类型，需要逐项 delete，否则会造成内存泄漏

● 频繁调用 push_back 影响：向vector 的尾部添加元素，很有可能引起整个对象存储空间的重新分配，这个过程是耗时耗力的。C++11之后，新增 emplace_back 方法，都是添加元素，但是该方法效率更高。emplace_back 在内存优化方面和运行效率方面有改进，内存优化方面主要体现在就地构造（直接在容器内构造对象，不用拷贝一个再使用） +强制类型转换，在运行效率方面，由于省去了拷贝构造，因此有提高。

list

STL中的 list 是一个双向循环链表，相比双向链表结构的好处是在构建 list 容器时，只需借助一个指针即可轻松表示 list 容器的首尾元素。

deque

支持从头尾两端进行元素的插入和删除操作，没有容量的概念，因为它是动态地以分段连续空间组合而成，随时可以增加一段新的空间并连接起来，但是拥有复杂的迭代器结构。deque 采用一块所谓的 map 作为主控，这里的 map 实际就是一块大小连续的空间，其中每一个元素称为节点 node，都指向了另一段连续线性空间，该空间是 deque 真正的存储空间。

deque 实现原理

1. 送代器是一个类，其中迭代器中的 node 变量指向 map 的一个单元，而 map 中的每个单元指向当前迭代器对应的数据（缓冲区），如下图所示。map 的实现为 vector。

2. 当某个数据缓冲区头部或尾部已满时，将回到 map 中定位到相邻的数据缓冲区。内部分段连续实现。

3. 当插入元素时，当前位置位于首部或尾部时，直接插入；否则比较当前元素距离首部近还是尾部近，距离哪边近则将当前位置那段的元素整体移动，再插入当前元素。

4. 堆和栈的实现原理

priority_queue

优先队列（ STL为大顶堆），每个节点大于其子节点，采用 vector 实现

map 和 set

STL 原理解析： https://www.bilibili.com/video/BV1NB4y1W7Uf?

spm_id_from=333.999.list.card_archive.click&vd_source=de7529d9789e1cd154061dd03f6490

map 和 set 都是C++的关联容器，其底层实现都是红黑树。

set 、multiset 使用红黑树的迭代器是 const 类型的。

map 、multimap 使用红黑树的迭代器不是 const 类型的。

（key 、val在内部是存储在一个元素中，因此set 、map底层实现一样）

红黑树（平衡二叉搜索树）

红黑树定义：

● 每个节点不是红色就是黑色

● 根节点必须是黑色，相邻节点颜色不一样

● 从根节点到叶子节点的黑色节点个数是一样的

实现：有个虚拟头结点，左右指针分别指向红黑树最左侧和最右侧节点，便于最大最小值查找。每个节点都有左右指针、父节点指针和K-V值（还有颜色值）为什么采用红黑树实现：

● 二叉树在某些情况下可能会退化为 O(N) 的时间复杂度；

● AVL树左右子树高度差最大为1，红黑树不遵循高度差条件，为的是减少旋转的次数

hashtable

STL 原理解析： https://www.bilibili.com/video/BV1NB4y1W7Uf?

spm_id_from=333.999.list.card_archive.click&vd_source=de7529d9789e1cd154061dd03f6490

hash 转换：

1. 整数值直接作为 hash 值

2. 字符串各字符处理（只要够乱就可）作为 hash 值

哈希表扩充：当元素个数大于 buckets 大小时，将会进行哈希表扩充（约2倍数扩充），并重新分配所有元素。

碰撞处理：同一位置用链表存储

实现： unordered_set 、unordered_map。

STL 底层实现

● 只有一个链表的头结点

● 每个桶指向上一个有效桶的最后一个节点（即上一个节点）

1.7 算法

memcpy 实现

void mymemcpy(void* dst, const void* src, size_t num) {
 assert((dst != nullptr) && (src != nullptr));
 const char* psrc = (const char*)src; //因为void*是⽆法完成 '++' 或 '--'
的
 char* pdst = (char*)dst;
 
 if (pdst > psrc && pdst < psrc + num) {
 for (size_t i = num - 1; i >= 0 && i < num; --i) {
 pdst[i] = psrc[i];
 }
 } else {
 for (size_t i = 0; i < num; ++i) {
 pdst[i] = psrc[i];
 }
 }
}

读写锁

class ReadWriteLock {
private:
std::mutex write;
std::shared_mutex read; // C++14
int readCnt;
public:
ReadWriteLock(): readCnt(0) {}
void readLock() {
read.lock();
if (++ readCnt == 1) {
write.lock();
}
read.unlock();
}
void unreadLock() {
read.lock();
if (-- readCnt == 0) {
write.unlock();
}
read.unlock();
}
void writeLock() {
write.lock();
}
void unwriteLock() {
write.unlock();
}
};

死锁复现代码

#include <iostream>
#include <thread>
#include <mutex>
#include <unistd.h>
using namespace std;
int data = 1;
mutex mt1,mt2;
void a2() {
mt2.lock();
sleep(1);
data = data * data;
mt1.lock(); //此时a1已经对mt1上锁，所以要等待
cout<<data<<endl;
mt1.unlock();
mt2.unlock();
}
void a1() {
mt1.lock();
sleep(1);
data = data+1;
mt2.lock(); //此时a2已经对mt2上锁，所以要等待
cout<<data<<endl;
mt2.unlock();
mt1.unlock();
}
int main() {
thread t2(a2);
thread t1(a1);
t1.join();
t2.join();
cout<<"main here"<<endl; //要t1线程、t2线程都执⾏完毕后才会执⾏
return 0;
}

⼆叉树序列号与反序列化

// 序列化
void serializeSub(TreeNode* node, string &res) {
 if (!node) {
 res += "NULL,";
 }
 else {
 res += to_string(node->val) + ",";
 serializeSub(node->left, res);
 serializeSub(node->right, res);
 }
}
string serialize(TreeNode* root) {
 string res = "";
 serializeSub(root, res);
 return res;
}
// 反序列化
TreeNode* deserializeSub(queue<string> &q) {
 string cur = q.front();
 q.pop();
 if (cur == "NULL") {
 return nullptr;
 }
 else {
 TreeNode *node = new TreeNode(stoi(cur));
 node->left = deserializeSub(q);
 node->right = deserializeSub(q);
 return node;
 }
}
TreeNode* deserialize(string data) {
 queue<string> q;
 string cur = "";
 for (char c: data) {
 if (c != ',') {
 cur += c;
 }
 else {
 q.push(cur);
 cur.clear();
 }
 }
return deserializeSub(q);
}

⽣产者消费者模式

#include <iostream>
#include <thread>
#include <vector>
#include <queue>
#include <mutex>
#include <condition_variable>
using namespace std;
#define PRODUCT_SIZE 2
#define CUSTUM_SIZE 2
#define POOL_SIZE 3
mutex m;
condition_variable cv;
queue<int> que;
int num = 0;
void producter() {
while (true) {
std::unique_lock<std::mutex> lck(m);
while (que.size() >= POOL_SIZE) {
cv.wait(lck);
}
int data = num ++;
que.push(data);
cout << this_thread::get_id() << "⽣产了" << data << endl;
cv.notify_all();
}
}
void customer() {
while (true) {
std::unique_lock<std::mutex> lck(m);
while (que.empty()) {
cv.wait(lck);
}
cout << this_thread::get_id() << "消费了" << que.front() << endl;
que.pop();
cv.notify_all();
}
}
int main() {
vector<thread> pools;
for (int i = 0; i < PRODUCT_SIZE; ++ i) {
pools.push_back(thread(producter));
}
for (int i = 0; i < CUSTUM_SIZE; ++ i) {
pools.push_back(thread(customer));
}
for (int i = 0; i < PRODUCT_SIZE + CUSTUM_SIZE; ++ i) {
pools[i].join();
}
return 0;
}

⼆叉树-前中后迭代算法模板

vector<int> inorderTraversal(TreeNode* root) {
 vector<int> res;
 stack<pair<TreeNode*, bool>> st;
 st.push({root, false}); // root 节点未被访问
 while (!st.empty()) {
 auto tmp = st.top();
 st.pop();
 if (!tmp.first) continue;
 if (!tmp.second) {
 TreeNode* node = tmp.first;
 
 // 对于其他顺序遍历，仅改变下⾯三⾏代码即可（遍历逆序）
 st.push({node->right, false});
 st.push({node, true});
 st.push({node->left, false});
 }
 else {
 res.emplace_back(tmp.first->val);
 }
 }
 return res;
}

⼿写智能指针

#include <iostream>
#include <cstdlib> // 智能指针头⽂件
#include <utility> // 智能指针头⽂件
#include <memory> // 智能指针头⽂件
template<typename T>
class SmartPtr {
private:
size_t* _count;
T* _ptr;
public:
// 构造函数
SmartPtr(T* ptr=nullptr): _ptr(ptr) {
if (ptr) {
_count = new size_t(1);
}
else {
_count = new size_t(0);
}
}
 
// 析构函数
~SmartPtr() {
if ((*_count) > 0) {
-- (*_count);
}
if ((*_count) == 0) {
delete _ptr;
delete _count;
_ptr = nullptr;
_count = nullptr;
}
}
 
// 拷⻉构造函数
SmartPtr(const SmartPtr& ptr) {
if (this == &ptr) {
return ;
}
_ptr = ptr._ptr;
_count = ptr._count;
(*_count) ++;
}
 
// 拷⻉赋值运算符
SmartPtr& operator=(const SmartPtr& ptr) {
if (_ptr == ptr._ptr) {
return *this;
}
_ptr = ptr._ptr;
_count = ptr._count;
(*_count) ++;
return *this;
}
 
T& operator*() const { return *_ptr; }
T* operator->() const { return _ptr; }
operator bool() const { return _ptr; }
size_t use_count() const { return *_count; }
};
int main() {
std::shared_ptr<int> p1(new int(3));
std::cout << p1.use_count() << std::endl; // 1
std::shared_ptr<int> p2(p1);
std::cout << p1.use_count() << std::endl; // 2
std::cout << p2.use_count() << std::endl; // 2
std::shared_ptr<int> p3;
std::cout << p3.use_count() << std::endl; // 0
p3 = p2;
std::cout << p2.use_count() << std::endl; // 3
std::cout << p3.use_count() << std::endl; // 3
std::shared_ptr<int> p4 = p3;
std::cout << p3.use_count() << std::endl; // 4
std::cout << p4.use_count() << std::endl; // 4
std::cout << std::endl << std::endl;
///
SmartPtr<int> sp1(new int(3));
std::cout << sp1.use_count() << std::endl; // 1
SmartPtr<int> sp2(sp1);
std::cout << sp1.use_count() << std::endl; // 2
std::cout << sp2.use_count() << std::endl; // 2
SmartPtr<int> sp3;
std::cout << sp3.use_count() << std::endl; // 0
sp3 = sp2;
std::cout << sp2.use_count() << std::endl; // 3
std::cout << sp3.use_count() << std::endl; // 3
SmartPtr<int> sp4 = sp3;
std::cout << sp3.use_count() << std::endl; // 4
std::cout << sp4.use_count() << std::endl; // 4
return 0;
}

⼗⼤排序算法（升序实现）

稳定排序：冒泡排序、插⼊排序、归并排序

冒泡排序：N个数需要进⾏N-1次冒泡，每次冒泡确定⼀个最⼤值位置。元素交换次数为原数组逆序度。

void bubbleSort(std::vector<int>& nums, int n) {
for (int i = 1; i < n; ++ i) { // 冒泡次数
bool is_swap = false;
for (int j = 1; j < n - i + 1; ++ j) {
if (nums[j] < nums[j - 1]) {
std::swap(nums[j], nums[j - 1]);
is_swap = true;
}
}
if (!is_swap) break;
}
}

插⼊排序：分为已排序和未排序，初始化已排序区间只有数组第⼀个元素。遍历未排序的每⼀个元素，倒序⽐较与已排序区间的⼤⼩关系，确定当前未排序元素的位置。元素交换次数为原数组逆序度。

void insertSort(std::vector<int>& nums, int n) {
for (int i = 1; i < n; ++ i) {
for (int j = i; j > 0 && nums[j] < nums[j - 1]; -- j) {
std::swap(nums[j], nums[j - 1]);
}
}
}

选择排序：从头开始遍历数组，然后将该元素与其后⾯的区间进⾏⽐较，选择最⼩的元素并交换

void selectSort(std::vector<int>& nums, int n) {
for (int i = 0; i < n - 1; ++ i) {
int k = i;
for (int j = i + 1; j < n; ++ j) {
if (nums[j] < nums[k]) {
k = j;
}
}
std::swap(nums[k], nums[i]);
}
}

快速排序：先找到⼀个枢纽，然后在当前数组中把⽐这个枢纽⼩的元素放左边，⼤的元素放右边，两部分数据依次递归排序下去直到有序。

void quickSort(std::vector<int>& nums, int l, int r) {
if (l >= r) return;
int left = l, right = r, key = nums[l];
while (left < right) {
while (left < right && nums[right] >= key) -- right;
while (left < right && nums[left] <= key) ++ left;
if (left < right) {
std::swap(nums[left], nums[right]);
}
}
std::swap(nums[left], nums[l]);
quickSort(nums, l, left - 1);
quickSort(nums, left + 1, r);
}

归并排序：⾸先将数组等分递归排序，然后通过⼀个临时数组，⽐较两个数组的⼤⼩从⽽合并两个数组。

void mergeSort(std::vector<int>& nums, int l, int r) {
if (l < r) {
int mid = l + (r - l ) / 2;
mergeSort(nums, l, mid);
mergeSort(nums, mid + 1, r);
 
 vector<int> tmp(r - l + 1);
 int i = l, j = mid + 1;
 int k = 0;
 while (i <= mid && j <= r) {
 if (nums[i] < nums[j]) {
 tmp[k ++] = nums[i ++];
 }
 else {
 tmp[k ++] = nums[j ++];
 }
 }
 
 while (i <= mid) { tmp[k ++] = nums[i ++]; }
 while (j <= r) { tmp[k ++] = nums[j ++]; }
 
 for (int p = 0; p < k; ++ p) {
 nums[l + p] = tmp[p];
 }
}
}

堆排序：从最后⼀个⽗节点逆序构建最⼤堆（根节点/0下标值为最⼤），然后循环N-1次，不断将0下标与最后下标数交换，并调整堆（其中堆越来越⼩）

void heapify(vector<int>& nums, int f, int n) {
int left = f * 2 + 1;
 int right = left + 1;
while (left < n) {
int index = f;
if (nums[index] < nums[left]) index = left;
if (right < n && nums[index] < nums[right]) index = right;
if (index == f) {
break;
}
else {
swap(nums[f], nums[index]);
f = index;
left = f * 2 + 1;
 right = left + 1;
}
}
}
void heapSort(std::vector<int>& nums, int n) {
if (n < 2) return ;
// 从最后⼀个⽗节点调整为最⼤堆
for (int i = n / 2 - 1; i >= 0; -- i) {
heapify(nums, i, n);
}
// 最⼤值放最后，将剩下调整为堆
for (int i = n - 1; i > 0; -- i) {
std::swap(nums[0], nums[i]);
heapify(nums, 0, i);
}
}

桶排序：将数据分到有限数量的桶⾥，然后每个桶分别排序（可能使⽤其他排序算法），最后每个桶内数据合并

计数排序：获取数组最⼤manV和最⼩值mixV，然后⽣成manV-mixV+1⼤⼩的数组，分别计数对应值的次数，然后再恢复数值输出结果

基数排序：针对正整数排序，对每⼀个数补⻬最⻓位数，然后从低位开始排序，排序的过程类似于多次桶排序

希尔排序：从 len/2 步⻓开始排序，每次步⻓取半，直到最后成为插⼊排序