手撕算法汇总

memcpy的实现：

void* memcpy(void*dest,const void*src,int length) {
	if (dest == NULL || src == NULL)
		return NULL;
	char* d = (char*)(dest);
	char* s = (char*)(src);

	//如果内存重叠，即dest>src且s+length-1>d 从下向上复制
	if (d>s && (s+length-1)>d) { 
		d = d + length - 1;
		s = s + length - 1;
		while (length--) {
			*d-- = *s--;		
		}
	}
	else {
		while (length--) {
			*d-- = *s--;	
		}
	}
	return dest;
}

实现map和vector的删除操作：

//map 常见的api find(“”)返回迭代器 找不到返回end   erase 
//map 中增加元素的方法，一种[]，一种insert,还有emplace, []会更新值,insert不会更新
//map中删除元素的方法erase 使迭代器失效
void removeMapElm(map<int,int>&mp) {
	auto it = mp.begin();
	while (it != mp.end()) {
		//如果大于10删除
		if (it->first>10) 
			it = mp.erase(it); //重新定位迭代器
		else
			it++;
	}
}

//vector api reserve预留一定的空间 resize调整已有元素的尺寸，并分配为0或者val 
//erase同样会有迭代器失效的问题
void removeVectorElm(vector<int>&v) {
	auto it = v.begin();
	while (it != v.end()) {
		if (*it > 10)
			it = v.erase(it);
		else
			it++;
	}
}

实现LRU：

struct node {
	struct node* prev;
	struct node* next;
	int key,val;
	node() :prev(nullptr),next(nullptr),val(0),key(0){}
	node(int key,int value) :prev(nullptr), next(nullptr), val(value),key(key) {}

};
class LRUCache {
public:
	LRUCache(int number=0);
	int get(int num);
	void put(int key,int value);
	void addTail(int key,int value);
	void removeHead();
	void removeNode(node* node);

private:
	map<int,node*>mp;
	node* head, *tail;
	int cur_sum;     //当前容量
	int max_number; //最大容量

};

//构造函数
LRUCache::LRUCache(int number) {
	head = new node();
	tail = new node();
	head->next = tail;
	tail->prev = head;
	max_number = number;
	cur_sum = 0;
	mp.clear();
}

//put实现
void LRUCache::put(int key,int value) {
	if (mp.find(key) != mp.end()) {
		removeNode(mp[key]);
		addTail(key, value);  //添加到队尾，最后被置换
		return;
	}
	if (cur_sum < max_number) {
		addTail(key, value);
		cur_sum++;
	}
	else {
		node* temp = head->next;
		mp.erase(mp.find(temp->key));  //需要擦除map中LRU首元素,erase要用迭代器来删除
		removeHead();
		addTail(key, value);
	}
}

//get 实现
int LRUCache::get(int key) {
	if (mp.find(key) != mp.end()) {
		int value = mp[key]->val;
		removeNode(mp[key]);
		addTail(key, value);  //添加到队尾，最后被置换
		return mp[key]->val;
	}
	else {
		return -1;
	}
}

//添加尾部
void LRUCache::addTail(int key,int value) {
	node* temp = new node(key,value);
	mp[key] = temp;
	node* prevTail = tail->prev;
	prevTail->next = temp;
	temp->prev = prevTail;
	tail->prev = temp;
	temp->next= tail;
	
}

//移除头部
void LRUCache::removeHead() {
	node* nextHead = head->next;
	head->next = nextHead->next;
	nextHead->next->prev = head;
	delete nextHead;
}

void LRUCache::removeNode(node* node) {
	struct node* preNode = node->prev;
	struct node* nextNode = node->next;
	preNode->next = nextNode;
	nextNode->prev = preNode;
	delete node;
}

自己实现一个string类：

class MyString {
public:
	MyString(const char*str);
	~MyString();
	MyString(const MyString& str);
	MyString& operator =(const MyString&str);
	friend ostream& operator <<(ostream& os, const MyString& str);
	char* getStr() { return m_str; }
    

private:
	char* m_str;
	size_t m_length;
};

//构造函数
MyString::MyString(const char* str="") {
	m_length = strlen(str);
	if (m_length != 0) {
		m_str = new char[m_length + 1];
		strcpy(m_str, str);
	}
}

//析构函数
MyString::~MyString() {
	delete[]m_str;
}

//拷贝构造
MyString::MyString(const MyString& str) {
	if (&str != this) {
		this->m_length = str.m_length;
		m_str = new char[m_length + 1];
		strcpy(m_str, str.m_str);
	}
}

//重载运算符=
MyString& MyString::operator =(const MyString& str) {
	if (this != &str) {
		delete []m_str;
		this->m_length = str.m_length;
		m_str = new char[m_length + 1];
		strcpy(m_str, str.m_str);
	}
	return *this;
}

//重载运算符<<
ostream& operator <<( ostream& os,const MyString &str) {
	os<< str.m_str;
	return os;
}