数据结构--LeetCode专题练习 Day8

75. 颜色分类

给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。

此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。

示例 1：

输入：nums = [2,0,2,1,1,0]
输出：[0,0,1,1,2,2]

示例 2：

输入：nums = [2,0,1]
输出：[0,1,2]

示例 3：

输入：nums = [0]
输出：[0]

示例 4：

输入：nums = [1]
输出：[1]

提示：

n == nums.length
1 <= n <= 300
nums[i] 为 0、1 或 2

原始思路：

sort排序

class Solution {
public:
    void sortColors(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        
        }    
};//0ms 8.2MB

其他思路：

1.哈希表
（1）记录数组中0,1,2的个数 （2）按照个数输出

class Solution {
public:
    void sortColors(vector<int>& nums) {
         unordered_map<int,int>m;
         for(int i=0;i<nums.size();i++){
             m[nums[i]]++;
         }
        vector<int> ans;
        for(int i=0;i<3;i++){
            while(m[i]!=0){
            ans.push_back(i);
            m[i]--;
            }
        }
        nums=ans;
    }
};//4ms 8.2MB 

2.单指针  O(n)

在第一次遍历中，我们将数组中所有的 0交换到数组的头部。
在第二次遍历中，我们将数组中所有的 1交换到头部的 0之后,此时，所有的 2都出现在数组的尾部

class Solution {
public:
    void sortColors(vector<int>& nums) {
        int n=nums.size();
		int p=0;//起始位置
		for(int i=0;i<n;i++){ //第一次遍历
			if(nums[i]==0){
				swap(nums[i],nums[p]);
				p++;
			}
		}
		for(int i=p;i<n;i++){
			if(nums[i]==1){
				swap(nums[i],nums[p]);
				p++;
			}
		}

    }
};

3.双指针  法一

一次遍历，使用两个指针分别用来交换0和1
p0换0，p1换1

class Solution {
public:
    void sortColors(vector<int>& nums) {
		int n=nums.size();
		int p0=0,p1=1;//初始位置
		for(int i=0;i<n;i++){
			if(nums[i]==1){  //p1换1
				swap(nums[i],nums[p1]);
				p1++;
			}else if(nums[i]==0){  //p0换0
				swap(nums[i],nums[p0]);
				//p0指着1 
				if(p0<p1){  //p1位置在p0后，将0与nums[p0] 进行交换，那么我们可能会把一个 1交换出去
					swap(nums[i],nums[p1]);//需要将这个1放到「头部」的末端。
				}
				//无论是否有p0<p1都需要将p0和p1后移
				p0++;
				p1++;
			}
		}
	}
};

4.双指针  法二

0挪到最前面，2挪到最后面
2 挪完如果换出来的不是 1，那么指针要回退，因为 0 和 2 都是需要再次移动的

class Solution {
public:
    void sortColors(vector<int>& nums) {
		int n=nums.size();
		if(n<2){
			return;
		}
		int p=0,q=n-1;
		for(int i=0;i<=q;i++){
			if(nums[i]==0){
				nums[i]=nums[p];
				nums[p]=0;
				p++;
			}
			if(nums[i]==2){
				nums[i]=nums[q];
				nums[q]=2;
				q--;
				if(nums[i]!=1){
					i--;
				}
			}
		}
		return;
	}
};

补充：

在大量数据的时候++i的性能要比i++的性能好原因：
i++由于是在使用当前值之后再+1，
所以需要一个临时的变量来转存。
而++i则是在直接+1，省去了对内存的操作的环节，相对而言能够提高性能。

56. 合并区间

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。

示例 1：

输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

示例 2：

输入：intervals = [[1,4],[4,5]]
输出：[[1,5]]
解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。
 

提示：

1 <= intervals.length <= 10 4
intervals[i].length == 2
0 <= starti <= endi <= 10 4

原始思路：

1.按照区间的左端点进行排序

2.比较数组的右端点是否在下一个数组内，若在则取下一个数组的右端点与该数组的左端点合成一个区间；若不在，正常输出该数组，并比较下一个数组

（问题：没有将区间比较出现的6中情况全部考虑在内，没有考虑用什么来存储合并后的结果）

思路更正：

用数组m存储最终答案
1.将列表中的区间按照左端点升序排序,将第一个区间加入m
2.考虑之后的区间：
当前区间的L>数组m中最后一个区间的R,则不重合，将当前区间加入数组m的末尾
否则重合，更新数组m中最后一个区间的R，将其置为二者最大值

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
		if(intervals.size()==0){
			return {};
		}
		sort(intervals.begin(),intervals.end());
		vector<vector<int>>m;
		for(int i=0;i<intervals.size();++i){
			int L=intervals[i][0],R=intervals[i][1];
			if(!m.size()||m.back()[1]<L){ //R<L,无重合
				m.push_back({L,R});//将其放入m的末尾
			}else{
				m.back()[1]=max(m.back()[1],R);//有重合，更新R
			}
		}
		return m;
	}
};//20ms 13.6MB

706. 设计哈希映射 

不使用任何内建的哈希表库设计一个哈希映射（HashMap）。

实现 MyHashMap 类：

MyHashMap() 用空映射初始化对象
void put(int key, int value) 向 HashMap 插入一个键值对 (key, value) 。如果 key 已经存在于映射中，则更新其对应的值 value 。
int get(int key) 返回特定的 key 所映射的 value ；如果映射中不包含 key 的映射，返回 -1 。
void remove(key) 如果映射中存在 key 的映射，则移除 key 和它所对应的 value 。
 

示例：

输入：
["MyHashMap", "put", "put", "get", "get", "put", "get", "remove", "get"]
[[], [1, 1], [2, 2], [1], [3], [2, 1], [2], [2], [2]]
输出：
[null, null, null, 1, -1, null, 1, null, -1]

解释：
MyHashMap myHashMap = new MyHashMap();
myHashMap.put(1, 1); // myHashMap 现在为 [[1,1]]
myHashMap.put(2, 2); // myHashMap 现在为 [[1,1], [2,2]]
myHashMap.get(1);    // 返回 1 ，myHashMap 现在为 [[1,1], [2,2]]
myHashMap.get(3);    // 返回 -1（未找到），myHashMap 现在为 [[1,1], [2,2]]
myHashMap.put(2, 1); // myHashMap 现在为 [[1,1], [2,1]]（更新已有的值）
myHashMap.get(2);    // 返回 1 ，myHashMap 现在为 [[1,1], [2,1]]
myHashMap.remove(2); // 删除键为 2 的数据，myHashMap 现在为 [[1,1]]
myHashMap.get(2);    // 返回 -1（未找到），myHashMap 现在为 [[1,1]]
提示：

0 <= key, value <= 106
最多调用 10 4 次 put、get 和 remove 方法
 

（暂时还没搞懂这题，先附上代码）

class MyHashMap {
private:
    vector<list<pair<int,int>>>data;
    static const int base=769;
    static int hash(int key){
        return key%base;
    }
public:
    /** Initialize your data structure here. */
    MyHashMap() :data(base){  //用空映射初始化对象

    }
    
    /** value will always be non-negative. */
    void put(int key, int value) { //向 HashMap 插入一个键值对
        int h=hash(key);
        for(auto it=data[h].begin();it!=data[h].end();it++){
            if((*it).first==key){
                (*it).second=value;
                return;
            }
        }
        data[h].push_back(make_pair(key,value));
    }
    
    /** Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key */
    int get(int key) {  //返回特定的 key 所映射的 value ,如果映射中不包含 key 的映射(值)，返回 -1
        int h=hash(key);
        for(auto it=data[h].begin();it!=data[h].end();it++){
            if((*it).first==key){
                return (*it).second;
            }
        }
        return -1;
    }
    
    /** Removes the mapping of the specified value key if this map contains a mapping for the key */
    void remove(int key) {  //如果映射中存在 key 的映射，则移除 key 和它所对应的 value 
        int h=hash(key);
        for(auto it=data[h].begin();it!=data[h].end();it++){
            if((*it).first==key){
                data[h].erase(it);
                return;
            }
        }
    }
};