466-82（3、146、215）

3. 无重复字符的最长子串

class Solution
{
public:
	int lengthOfLongestSubstring(string s)
	{
		if (s.size() == 0) return 0;

		unordered_set<char> look;
		int res = 0;
		int left = 0;

		for (int i = 0; i < s.size(); i++)
		{
			while (look.find(s[i]) != look.end())
			{
				look.erase(s[left]);
				left++;
			}
			res = std::max(res, i - left + 1);
			look.insert(s[i]);
		}
		return res;
	}
};

146. LRU 缓存

class LRUCache {
private:

    struct link_node
    {
        int key, value;
        link_node* pre;
        link_node* next;
        link_node() :key(0), value(0), pre(nullptr), next(nullptr) {}
        link_node(int _key, int _value)
            : key(_key), value(_value), pre(nullptr), next(nullptr) {}
    };

    unordered_map<int, link_node*> cache;
    link_node* dummy_head;
    link_node* dummy_tail;
    int size;
    int capacity;



public:
    LRUCache(int _capacity) : capacity(_capacity), size(0) {
        // 使用伪头部和伪尾部节点
        dummy_head = new link_node();
        dummy_tail = new link_node();
        dummy_head->next = dummy_tail;
        dummy_tail->pre = dummy_head;
    }

    int get(int key) {
        if (!cache.count(key))
            return -1;

        // 如果 key 存在，先通过哈希表定位，再移到头部
        link_node* node = cache[key];
        move_to_head(node);
        return node->value;
    }

    void put(int key, int value) {
        if (cache.count(key)) {
            //已经有节点key，就更新节点的value值
            link_node* node = cache[key];
            node->value = value;
            move_to_head(node);
        }
        else {
            link_node* node = new link_node(key, value);
            add_to_head(node);
            //添加进哈希表
            cache[key] = node;
            size++;
            if (size > capacity) {
                //如果超出容量，删除双向链表的尾部节点
                //先获得这个即将删除的节点
                link_node* removed = remove_tail();
                //删除哈希表中的对应项
                cache.erase(removed->key);
                delete removed;
                size--;
            }
        }
    }

    void add_to_head(link_node* node) {
        node->pre = dummy_head;
        node->next = dummy_head->next;
        dummy_head->next->pre = node;
        dummy_head->next = node;
    }

    void remove_node(link_node* node){
        node->pre->next = node->next;
        node->next->pre = node->pre;
    }

    void move_to_head(link_node* node) {
        remove_node(node);
        add_to_head(node);
    }

    //删除最尾部的节点
    //函数的意义：原表中已经删除了，返回需要删除的node节点
    link_node* remove_tail() {
        link_node* temp = dummy_tail->pre;
        remove_node(temp);
        return temp;
    }
};

215. 数组中的第K个最大元素

class Solution
{
	int Partation(vector<int>& arr, int l, int r)
	{
		int val = arr[l];

		while (l < r)
		{
			while (l < r && arr[r] > val)
			{
				r--;
			}

			if (l < r)
			{
				arr[l] = arr[r];
				l++;
			}

			while (l < r && arr[l] < val)
			{
				l++;
			}

			if (l < r)
			{
				arr[r] = arr[l];
				r--;
			}
		}
        arr[l] = val;
        return l;
	}

	void QuickSort(vector<int>& arr, int begin, int end)
	{
		if (begin >= end)
		{
			return;
		}

		int pos = Partation(arr, begin, end);
		QuickSort(arr, begin, pos - 1);
		QuickSort(arr, pos + 1, end);
	}

public:
	int findKthLargest(vector<int>& nums, int k)
	{
		int size = nums.size();
		QuickSort(nums, 0, size - 1);
		return nums[size - k];
	}
};