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

136. 只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：

你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

示例 1:

输入: [2,2,1]
输出: 1
示例 2:

输入: [4,1,2,1,2]
输出: 4

原始思路：

//1.使用哈希表记录每个数字出现的次数2.输出次数为1的数

//1.排序2.与左右数字相比较，若不等，则输出该数字

更正思路：

1.排序

（1）排序（2）与左右数字相比较，若不等，则输出该数字（注意排序的最后一个数字）

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        for(int i = 0; i < nums.size(); i += 2)
        {
            if(i == nums.size() - 1)    return nums[i];
            if(nums[i] != nums[i + 1])  return nums[i];
        }
        return -1;
    }
};//20ms 16.6MB

另一种写法：

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int ans;
        sort(nums.begin(), nums.end());
        for(int i = 0; i < nums.size() - 1; i += 2){
            if(nums[i] != nums[i + 1])
            {
                ans = nums[i];
                return ans;
            }
        }   
        ans = nums[nums.size() - 1];
        return ans;
    }
};

2.哈希表

第一次出现插入哈希表；

第二次出现，则在hash中删除该数字；

最后输出剩下的一个数

class Solution {
public:
    int singleNumber(vector<int>& nums) {
		unordered_set<int>m;
		int ans;
		for(int i=0;i<nums.size();i++){
			int num=nums[i];
			if(m.count(num)){
				m.erase(num);
			}else{
				m.insert(num);
			}
		}
		for(int j:m) ans=j;
		return ans;
	}
};

3.位运算  异或

任何数和 0做异或运算，结果仍然是原来的数，即 a⊕0=a。
任何数和其自身做异或运算，结果是 0，即a⊕a=0。
异或运算满足交换律和结合律，即 a⊕b⊕a=b⊕a⊕a=b⊕(a⊕a)=b⊕0=b。
该题：0⊕0⊕⋯⊕0⊕a m+1=a m+1

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int ret = 0;
        for (auto e: nums) ret ^= e;
        return ret;
    }
};

169. 多数元素

给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

示例 1：

输入：[3,2,3]
输出：3

示例 2：

输入：[2,2,1,1,1,2,2]
输出：2

原始思路： 哈希表
1.记录每个元素出现的次数 2.与n/2进行比较
/*使用哈希映射（HashMap）来存储每个元素以及出现的次数。对于哈希映射中的每个键值对，键表示一个元素，值表示该元素出现的次数*/

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        unordered_map<int,int>m;
        int n=nums.size();
        for(int i=0;i<n;i++){
            m[nums[i]]++;
            if(m[nums[i]]>n/2){
                return nums[i];
            }
        }
        return -1;
    }
};//16ms 19.3MB

其他思路：

1.排序 O(nlogn)

（1）排序 （2）排序后下标为n/2的元素一定是众数

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        return nums[nums.size() / 2];
    }
};

2.随机化 

期望的时间复杂度为 O(n),最坏情况为无穷
因为超过⌊n/2⌋ 的数组下标被众数占据了，这样我们随机挑选一个下标对应的元素并验证，有很大的概率能找到众数。

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        while (true) {
            int candidate = nums[rand() % nums.size()];//随机
            int count = 0;
            for (int num : nums)
                if (num == candidate)
                    ++count;
            if (count > nums.size() / 2)
                return candidate;
        }
        return -1;
    }
};

3.摩尔投票法

候选人p初始化为nums[0],票数count初始化为1
当遇到与p相同的数，票数count=count+1，否则票数减去1
当票数==0时，更换候选人，并将票数重新置为1
遍历结束后，p为最终答案

class Solution {
public:
    int majorityElement(vector<int>& nums) {
		int p=nums[0],count=1;
		for(int i=0;i<nums.size();i++){
			if(p==nums[i]){
				count++;
			}else if(--count==0){
				p=nums[i];
				count=1;
			}
		}
		return p;
	}
};//12ms  19.3MB

15. 三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。

注意：答案中不可以包含重复的三元组。

示例 1：

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

示例 2：

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

示例 3：

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

原始思路：
1.排序，左负右正

2.指针选择第一个负数与最后一个正数比较（相加）为负则选正数，为正则选负数；若无匹配的数，则指针后移
（在比较后如何选正数和负数没有交代清楚）

以下是原始代码，有一些问题：没有判特，没有确定比较成立的条件，没有想到“左”和“右”

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        sort(nums.begin(),nums.end());
         vector<vector<int>> result;
        int n=nums.size();
        int i,j,n_1,n_2,ans;
        for(i=0;i<n;i++){
            if(nums[i]>0){
               n_1=i;
               n_2=n-i;
            }
        }
        for(i=0;i<n_1;i++){
            for(j=n-1;j>n_2;j--){
                ans=nums[i]+nums[j];
                if(ans<0){
                    for(int k=j-1;k>n_2;k++){
                        if(nums[k]==ans){
                            return result;
                        }else{
                            i++;
                        }
                    }
                }else if(ans>0){
                   for(int k=i+1;k<n_1;k++){
                      if(nums[k]==ans){
                            return result;
                        }else{
                            i++;
                        } 
                   } 
                }else{
                    return result;
                } 
            }
        }
        return result;
    }
};

更正思路：

1.双指针

1.特判，对于数组长度n，如果数组为 null或者数组长度小于3，返回[]。
2.对数组进行排序。
3.遍历排序后数组：
若nums[i]>0：因为已经排序好，所以后面不可能有三个数加和等于0，直接返回结果。
对于重复元素：跳过，避免出现重复解
令左指针L=i+1，右指针R=n−1，当L<R 时，执行循环：
当nums[i]+nums[L]+nums[R]==0，执行循环，判断左界和右界是否和下一位置重复，去除重复解。并同时将L,R 移到下一位置，寻找新的解
若和大于0，说明nums[R] 太大,R 左移
若和小于0，说明nums[L] 太小,L 右移

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
		vector<vector<int>>ans;
		if(nums.size()<3) return ans;
	    sort(nums.begin(),nums.end());
		if(nums[0]>0) return ans;
		int i=0;
		while(i<nums.size()){
			if(nums[i]>0) break;// 如果当前数字大于0，则三数之和一定大于0，所以结束循环
			int left=i+1,right=nums.size()-1;
			while(left<right){
				int x=nums[i],y=nums[left],z=nums[right];
				if(x+y+z>0) right--;
				else if(x+y+z<0) left++;
				else{
					ans.push_back({nums[i],nums[left],nums[right]});
					//去重
					while(left<right&&nums[left]==nums[left+1]) left++;
					while(left<right&&nums[right]==nums[right-1])right--;
					//完成一组答案后指针前进和后退
					left++;
					right--;
				}
			}
			//避免nums[i]作为第一个数重复出现
			while(i+1<nums.size()&&nums[i]==nums[i+1]) i++;
			i++;
		}
		return ans;
	}
};