面试题——各种功能函数实现（一）
面试题——各种功能函数实现（三）
实现自己的memcpy
void *my_memcpy(void *dest, void *src, int num){
assert(dest != NULL && src != NULL);
char *pdest = (char *)dest;
char *psrc = (char *)src;
while(num--){
*pdest = *psrc;
pdest++;
psrc++;
}
return dest;
}
实现LRU缓存机制
这个思路是维护一个hash用来快速查找，维护一个双向链表使得有序，新访问的元素放前面，若满了，pop_back删除最后元素
class LRUCache {
list<pair<int, int>> cache;
unordered_map<int, list<pair<int, int>>::iterator> map;
int cap;
public:
LRUCache(int capacity) {
cap = capacity;
}
int get(int key) {
if (map.count(key) > 0){
//注意，这里一定要得到实体temp，而不是迭代器temp，因为后面erase会丢失
auto temp = *map[key];
cache.erase(map[key]);
map.erase(key);
cache.push_front(temp);
map[key] = cache.begin();
return temp.second;
}
return -1;
}
void put(int key, int value) {
if (map.count(key) > 0){
cache.erase(map[key]);
map.erase(key);
}
else if (cap == cache.size()){
auto temp = cache.back();
cache.pop_back();
map.erase(temp.first);
}
cache.push_front(pair<int, int>(key, value));
map[key] = cache.begin();
}
};
/**
* Your LRUCache object will be instantiated and called as such:
* LRUCache* obj = new LRUCache(capacity);
* int param_1 = obj->get(key);
* obj->put(key,value);
*/
实现平衡树旋转
#include 实现一个多态
#include 多线程与互斥锁简单实例
#include生产者消费者模型简单实现
原理
存储的数据的区域可以用一个队列来模拟，然后我们通过C++11提供的条件变量来通知写入线程在数据不满的时候进行写入，在数据满的时候挂起，对读取线程也是同理。
#include string类的实现
class my_string
{
public:
my_string(char *str == nullptr);
~my_string();
my_string(const my_string& other);
my_string& operator=(const my_string& other);
private:
char *m_data;
};
my_string::my_string(char *str){
if (str == nullptr){
m_data = new char[1];
m_data = '\0';
}
else{
int len = strlen(str);
m_data = new char[len+1];
strcpy(m_data, str);
}
}
my_string::my_string(const my_string& other){
int len = strlen(other.m_data);
m_data = new char[len+1];
strcpy(m_data, other.m_data);
}
my_string& my_string::operator=(const my_string& other){
if (this == &other)
return *this;
delete[] m_data;
int len = strlen(other.m_data);
m_data = new char[len+1];
strcpy(m_data, other.m_data);
return *this;
}
my_string::~my_string(){
if (m_data != nullptr){
delete[] m_data;
m_data = nullptr;
}
}
抢红包算法
两倍均值法
#include 另一种方法是先为每个人分配0.01元，然后开始随机抽取一个红包增加0.01元，直到总金额为0
真正随机的是第三种方法，线段法：
1、如何确定每一条子线段的长度呢？由“切割点”来决定。当N个人一起抢红包的时候，就需要确定N-1个切割点。
2、因此，当N个人一起抢总金额为M的红包时，我们需要做N-1次随机运算，以此确定N-1个切割点。随机的范围区间是（1， M）。
3、当所有切割点确定以后，子线段的长度也随之确定。这样每个人来抢红包的时候，只需要顺次领取与子线段长度等价的红包金额即可。
#include 洗牌算法
#include 实现单例模式
有两种方式，一个是懒汉式，一个是饿汉式。懒汉式需要考虑加锁。
#include 下面是饿汉式：
#include 实现strcpy
char* Strcpy(char* dst, const char* source){
assert(dst != NULL && source != NULL);
char* re = dst;
while ((*dst++ == *source++) != '\0');
return re;
}
shared共享指针实现
#include 简单工程模式
#include 抽象工程模式
#include 循环队列实现
class MyCircularQueue {
private:
vector<int> data;
int head;
int tail;
int size;
public:
/** Initialize your data structure here. Set the size of the queue to be k. */
MyCircularQueue(int k) {
data.resize(k);
head = -1;
tail = -1;
size = k;
}
/** Insert an element into the circular queue. Return true if the operation is successful. */
bool enQueue(int value) {
if (isFull()) {
return false;
}
if (isEmpty()) {
head = 0;
}
tail = (tail + 1) % size;
data[tail] = value;
return true;
}
/** Delete an element from the circular queue. Return true if the operation is successful. */
bool deQueue() {
if (isEmpty()) {
return false;
}
if (head == tail) {
head = -1;
tail = -1;
return true;
}
head = (head + 1) % size;
return true;
}
/** Get the front item from the queue. */
int Front() {
if (isEmpty()) {
return -1;
}
return data[head];
}
/** Get the last item from the queue. */
int Rear() {
if (isEmpty()) {
return -1;
}
return data[tail];
}
/** Checks whether the circular queue is empty or not. */
bool isEmpty() {
return head == -1;
}
/** Checks whether the circular queue is full or not. */
bool isFull() {
return ((tail + 1) % size) == head;
}
};
**
* Your MyCircularQueue object will be instantiated and called as such:
* MyCircularQueue obj = new MyCircularQueue(k);
* bool param_1 = obj.enQueue(value);
* bool param_2 = obj.deQueue();
* int param_3 = obj.Front();
* int param_4 = obj.Rear();
* bool param_5 = obj.isEmpty();
* bool param_6 = obj.isFull();
*/