Leetcode“存在重复元素“的多种排序算法实现

最近刷leetcode，遇到一题记录下
LC存在重复元素

给定一个整数数组，判断是否存在重复元素。

如果任意一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。

最初采用最简单的遍历,结果显示超时

/*遍历算法*/
class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        if (nums.size() == 0 || nums.size() == 1){
            return false;
        }
        for (int i = 0;i < nums.size();i++){
            for (int j = 0;j < i;j++){
                if (nums[i] == nums[j]){
                    return true;
                }
            }
        }
        return false;
    }
};

考虑了下该算法，时间复杂度高达O(n²)，而且这种遍历模式比较像冒泡排序，所以考虑用排序算法来实现先排序，后查找；由于排序后是有序序列，查找相同元素遍历就能实现，则排序后算法复杂度为O(n)，排序算法复杂度大于O(n)，两者相加，得出最终算法复杂度取决于排序算法复杂度。
下面将尝试多种算法，并比对其在这条算法题内的优劣。

希尔排序

代码

/*希尔排序*/
class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        if (nums.size() == 0 || nums.size() == 1){
            return false;
        }
        for(int i = nums.size() / 2;i > 0;i = i /2){
            for (int j = i;j < nums.size();j++){
                int k = j;
                int current = nums[k];
                while((k - i >= 0) && (nums[k - i] > current)){
                    nums[k] = nums[k - i];
                    k = k - i;
                }
                nums[k] = current;
            }
        }
        for(int  i = 0; i < nums.size() - 1;i++){
            if (nums[i] == nums[i + 1]){
                return true;
            }
        }
        return false;
    }
};

结果

归并排序

代码

/*归并排序*/
class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        if (nums.size() < 2){
            return false;
        }
		nums = mergeSort(nums);
		for (int i = 0;i < nums.size() - 1;i++){
			if (nums[i] == nums[i + 1]){
				return true;
			}
		}
		return false;
    }
	vector<int> mergeSort(vector<int> nums){
		if (nums.size() < 2){
			return nums;
		}
		int halfLen = nums.size() / 2;
		vector<int> numsLeft;
		vector<int> numsRight;
		for (int i = 0;i < halfLen;i++){
			numsLeft.push_back(nums[i]);
		}
		for (int i = halfLen;i < nums.size();i++){
			numsRight.push_back(nums[i]);
		}
		return merge(mergeSort(numsLeft),mergeSort(numsRight));
	}

	vector<int> merge(vector<int> numsLeft,vector<int> numsRight){
		vector<int> nums;
		int iLeft = 0;
		int iRight = 0;
		while((numsLeft.size() > iLeft) && (numsRight.size() > iRight)){
			if (numsLeft[iLeft] < numsRight[iRight]){
				nums.push_back(numsLeft[iLeft]);
				iLeft++;
			}else{
				nums.push_back(numsRight[iRight]);
				iRight++;
			}
		}
		while(numsLeft.size() > iLeft){
			nums.push_back(numsLeft[iLeft]);
			iLeft++;
		}

		while(numsRight.size() > iRight){
			nums.push_back(numsRight[iRight]);
			iRight++;
		}

		return nums;
	}
};

结果