1.链表反转

//链表
struct ListNode
{
	int m_val;
	ListNode* m_pNext;
	ListNode() :m_val(0), m_pNext(nullptr) {}
	ListNode(int x) :m_val(x), m_pNext(nullptr) {}
	ListNode(int x, ListNode* next) :m_val(x), m_pNext(next) {}
};


//迭代法，保存所有状态变量 ：pre->cur->next; O(N),O(1)
ListNode* reverseListTwoPointer(ListNode* head)
{
	if (!head) return nullptr;
	ListNode* next = nullptr, * cur = head, * pre = nullptr;
	while (cur)
	{
		next = cur->m_pNext;
		cur->m_pNext = pre;
		pre = cur;
		cur = next;
	}
	return pre;
}

2.快速排序

void QuikSort(vector<int>& nums, int left, int right)
{
	if (left > right) return;
	int index = PartSort(nums, left, right);
	QuikSort(nums, left, index - 1);
	QuikSort(nums, index + 1, right);
}

int PartSort(vector<int>& nums, int left, int right)
{
	int& base = nums[left];
	while (left < right)
	{
		while (left<right && nums[right]>=base)
		{
			--right;
		}
		while (left<right && nums[left]<=base)
		{
			++left;
		}
		swap(nums[left], nums[right]);
	}
	swap(base, nums[left]);
	return left;
}

void QuikSortNoRecurse(vector<int>& nums)
{
	int left = 0, right = nums.size() - 1, base = nums[left];
	stack<int> indexs;
	indexs.push(left);
	indexs.push(right);
	while (!indexs.empty())
	{
		right = indexs.top(); indexs.pop();
		left = indexs.top(); indexs.pop();
		int index = PartSort(nums, left, right);
		if (left<index -1)
		{
			indexs.push(left);
			indexs.push(index - 1);
		}
		if (right>index+1)
		{
			indexs.push(index + 1);
			indexs.push(right);
		}
	}
}

3.堆排序

void KeepHeap(vector<int>& nums, int index, int len)
{
	int left = 2 * index + 1 , right = 2 * index + 2, max = index;
	if (left < len && nums[left]>nums[max]) max = left;
	if (right < len && nums[right]>nums[max]) max = right;
	if (max!=index)
	{
		swap(nums[index], nums[max]);
		KeepHeap(nums, max, len);
	}
}

void BuildHeapForSort(vector<int>& nums, int heapsize)
{
	//从堆底及进行维护
	for (int i = heapsize/2; i >= 0; i--)
	{
		KeepHeap(nums, i, heapsize);
	}
}

void HeapSort(vector<int>& nums)
{
	BuildHeapForSort(nums, nums.size());
	for (int i = nums.size()-1; i >= 1; i--)
	{
		swap(nums[0], nums[i]);
		KeepHeap(nums, 0, i);
		//BuildHeapForSort(nums, i);//这二者都可以
	}
}

4.二叉树遍历

定义

struct BiTreeNode
{
	int m_val;
	BiTreeNode* m_pLeft;
	BiTreeNode* m_pRight;
    BiTreeNode() : m_val(0), m_pLeft(nullptr), m_pRight(nullptr) {}
    BiTreeNode(int x) : m_val(x), m_pLeft(nullptr), m_pRight(nullptr) {}
    BiTreeNode(int x, BiTreeNode* left, BiTreeNode* right) : m_val(x), m_pLeft(left), m_pRight(right) {}
};

struct BTStatusNode
{
	BiTreeNode* m_pNode;
	bool m_visited;
	BTStatusNode():m_pNode(nullptr),m_visited(false){}
	BTStatusNode(BiTreeNode* node,bool isVisited):m_pNode(node),m_visited(isVisited){}
};

1.前序

void PreOrder(BiTreeNode* root)
{
	if (!root) return;
	cout << root->m_val << " ";
	PreOrder(root->m_pLeft);
	PreOrder(root->m_pRight);
}

void PreOrderNotRecurse(BiTreeNode* root)
{
	if (!root) return;
	stack<BiTreeNode*> nodes;
	while (root || !nodes.empty())
	{
		while (root)
		{
			cout << root->m_val << " ";
			nodes.push(root);
			root = root->m_pLeft;
		}
		if (!nodes.empty())
		{
			root = nodes.top();
			nodes.pop();
			root = root->m_pRight;
		}
	}
}

2.中序

void InOrder(BiTreeNode* root)
{
	if (!root) return;
	InOrder(root->m_pLeft);
	cout << root->m_val <<" ";
	InOrder(root->m_pLeft);
}

void InOrderNotRecurse(BiTreeNode* root)
{
	if (!root) return;
	stack<BiTreeNode*> nodes;
	while (!root || !nodes.empty())
	{
		while (root)
		{
			nodes.push(root);
			root = root->m_pLeft;
		}
		if (!nodes.empty())
		{
			root = nodes.top();
			cout << root->m_val << " ";
			nodes.pop();
			root = root->m_pRight;
		}
	}
}

3.后序

void PostOrder(BiTreeNode* root)
{
	if (!root) return;
	PostOrder(root->m_pLeft);
	PostOrder(root->m_pRight);
	cout << root->m_val << " ";
}

void PostOrderNotRecurse(BiTreeNode* root)
{
	if (!root) return;
	stack<BTStatusNode> statusNodes;
	BTStatusNode tempNode;
	while (root||!statusNodes.empty())
	{
		while (root)
		{
			BTStatusNode node(root, false);
			statusNodes.push(node);
			root = root->m_pLeft;
		}
		if (!statusNodes.empty())
		{
			tempNode = statusNodes.top();
			statusNodes.pop();
			if (tempNode.m_visited == false)
			{
				tempNode.m_visited = true;
				statusNodes.push(tempNode);
				root = tempNode.m_pNode->m_pRight;
			}
			else
			{
				cout << tempNode.m_pNode->m_val << " ";
			}
		}
	}
}

5.LRU

struct DLinkNode
{
public:
	int _val;
	int _key;
	DLinkNode* _pre;
	DLinkNode* _next;
	DLinkNode(): _key(0), _val(0), _pre(nullptr), _next(nullptr) {};
	DLinkNode(int key, int val) :_key(key), _val(val) {};
	DLinkNode(int key, int val,DLinkNode* pre,DLinkNode* next) :_key(key), _val(val),_pre(pre),_next(next) {};
};

class LRUCache
{
public:
	LRUCache(int capacity);
	~LRUCache();
	int get(int key);
	void put(int key, int val);
	void moveNodeToHead(DLinkNode* node);
	void addToHead(DLinkNode* pNode);
	DLinkNode* removeTailNode();

private:
	int _capacity;
	map<int, DLinkNode*> _nodes;
	DLinkNode* _head;
	DLinkNode* _tail;
};

LRUCache::LRUCache(int capacity)
{
	_capacity = capacity;
	_head = new DLinkNode;
	_tail = new DLinkNode;
	_head->_next = _tail;
	_tail->_pre = _head;
}

int LRUCache::get(int key)
{
	if (!_nodes.count(key))
	{
		return -1;
	}
	else
	{
		DLinkNode* pnode = _nodes[key];
		moveNodeToHead(pnode);
		return pnode->_val;
	}
}

void LRUCache::put(int key, int val)
{
	if (!_nodes.count(key))
	{
		DLinkNode* pNode = new DLinkNode(key, val);
		_nodes[key] = pNode;
		//新建节点应加在头节点后！！！！！！
		addToHead(pNode);
		if (_nodes.size()<=_capacity)
		{
			moveNodeToHead(pNode);
		}
		else
		{
			DLinkNode* pNode = removeTailNode();
			_nodes.erase(pNode->_key);
			delete pNode;
		}
	}
	else
	{
		DLinkNode* pNode = _nodes[key];
		pNode->_val = val;
		moveNodeToHead(pNode);
	}
}

void LRUCache::moveNodeToHead(DLinkNode* node)
{
	if (node)
	{
		//删除节点时，顺序不重要
		node->_pre->_next = node->_next;
		node->_next->_pre = node->_pre;
		//插入节点时，先处理插入节点与其后一个节点之间的链接。
		addToHead(node);
	}
}

void LRUCache::addToHead(DLinkNode* pNode)
{
	pNode->_next = _head->_next;
	_head->_next->_pre = pNode;
	_head->_next = pNode;
	pNode->_pre = _head;
}

DLinkNode* LRUCache::removeTailNode()
{
	DLinkNode* node = _tail->_pre;
	_tail->_pre = _tail->_pre->_pre;
	_tail->_pre->_next = _tail;
	_nodes.erase(node->_key);
	return node;
}

6.LFU

struct LFUNode
{
	int _key, _val, _freq;
	LFUNode(int key, int val, int freq) :_key(key), _val(val), _freq(freq) {};
};

class LFUCache
{
	int _minfreq, _capacity;
	unordered_map<int, list<LFUNode>::iterator> _key_table;
	unordered_map<int, list<LFUNode>> _freq_table;
public:
	LFUCache(int capacity) :_capacity(capacity)
	{
		_minfreq = 0;
		_key_table.clear();
		_freq_table.clear();
	}
	int get(int key)
	{
		if (_capacity == 0) return -1;
		auto it = _key_table.find(key);
		if (it == _key_table.end()) return -1;
		list<LFUNode>::iterator it2 = it->second;
		int val = it2->_val, freq = it2->_freq;
		//从频率的list中移除当前频率的节点
		_freq_table[freq].erase(it2);
		if (_freq_table[freq].size()==0)
		{
			_freq_table.erase(freq);
			if (_minfreq == freq)
			{
				_minfreq += 1;
			}
		}
		//在新的频率list中插入节点
		_freq_table[freq + 1].push_front(LFUNode(key, val, freq + 1));
		_key_table[key] = _freq_table[freq + 1].begin();
		return val;
	}

	void put(int key, int val)
	{
		if (_capacity == 0) return;
		//迭代器
		auto it = _key_table.find(key);
		if (it == _key_table.end())
		{
			//判断缓存是否已满
			if (_key_table.size()==_capacity)
			{
				//获取最小使用频率的最不常使用节点(不是指针)
				auto it2 = _freq_table[_minfreq].back();
				_key_table.erase(it2._key);
				_freq_table[_minfreq].pop_back();
				if (_freq_table[_minfreq].size()==0)
				{
					_freq_table.erase(_minfreq);
				}
			}
			_freq_table[1].push_front(LFUNode(key, val, 1));
			_key_table[key] = _freq_table[1].begin();
			_minfreq = 1;
		}
		else
		{
			list<LFUNode>::iterator pnode = it->second;
			int freq = pnode->_freq;
			_freq_table[freq].erase(pnode);
			if (_freq_table[freq].size()==0)
			{
				_freq_table.erase(freq);
				if (_minfreq == freq)
				{
					_minfreq += 1;
				}
			}
			_freq_table[freq + 1].push_front(LFUNode(key, val, freq + 1));
			_key_table[key] = _freq_table[freq + 1].begin();
		}
	}
};