169. Majority Element（查找多数元素）

这题难度不大，直接用两层循环暴力求解可以AC：

class Solution {
public:
	int majorityElement(vector<int>& nums) {
		int res = -2147483647;
		int result;
		int length = nums.size();
		for (int i = 0; i < length; i++) {
			int count = 0, tmp = -2147483647, flag = nums[i];
			if (flag != -2147483647) {
				for (int j = 0; j < length; j++) {
					if (flag == nums[j] && nums[j] != -2147483647) {
						count++;
						tmp = nums[j];
						nums[j] = -2147483647;
					}
				}
				if (count > res) {
					res = count;
					result = tmp;
				}
			}
		}
		return result;
	}
};

当然这样暴力求解没有什么意思，于是我选择用了分治算法，主要思想就是找出数组中间值，将数组一分为二，找出新的两个数组中的多数元素X、Y，若X=Y则直接返回，否则对整个数组进行遍历，找出X、Y出现次数更多的元素。由于是分成两半进行递归且仍需要遍历数组，因此复杂度应为O(nlogn)。

int myMajor(vector<int> nums) {
	int len = nums.size();
	if (len == 1)
		return nums[0];
	vector<int> vec1(nums.begin(), nums.begin() + len / 2);
	int l = myMajor(vec1);
	vector<int> vec2(nums.begin() + len / 2, nums.begin() + len);
	int r = myMajor(vec2);
	if (l == r)
		return l;
	else {
		int count1 = 0, count2 = 0;
		for (int i = 0; i < len; i++) {
			if (nums[i] == l)
				count1++;
			if (nums[i] == r)
				count2++;
		}
		return (count1 > count2) ? l : r;
	}
}

class Solution {
public:
	int majorityElement(vector<int>& nums) {
		return myMajor(nums);
	}
};

但是我觉得每次递归都要新开vector来存储，过于浪费空间，于是打算直接用原始vector作为参数代入递归之中，做法同上。但是在做题过程中一直出错，经过长时间的调试才发现递归结束的vector并未发生改变，才知道原来是传入递归的参数是vector而不是vector&，因此只是传入了vector的拷贝，数据怎么修改都不会影响原vector。从此之后估计自己怎么都不会忘记深复制浅复制的区别了...

int myMajor(vector<int>& vec, int size, int beg) {
	if (size == 1)
		return vec[beg];
	int l = myMajor(vec, size / 2, beg);
	int r = myMajor(vec, size - size / 2, beg + size / 2);
	if (l == r)
		return l;
	else {
		int count1 = 0, count2 = 0;
		for (int i = beg; i < size; i++) {
			if (vec[i] == l)
				count1++;
			if (vec[i] == r)
				count2++;
		}
		return (count1 > count2) ? l : r;
	}
}

class Solution {
public:
	int majorityElement(vector<int>& nums) {
		int len = nums.size();
		return myMajor(nums, len, 0);
	}
};

做完分治之后，从网上又看了一下其他大神的做法，发现竟然有复杂度为O(n)的算法。先定义一个计数器count与一个默认多数元素，再对数组进行遍历，遇到相同的元素count++，否则count--，相当于此不相同的元素与默认多数元素相互“抵消”，直到count=0时更新默认多数元素。

class Solution {
public:
	int majorityElement(vector<int>& nums) {
		int elem = 0;
		int count = 0;
		int l = nums.size();
		for (int i = 0; i < l; i++) {
			if (count == 0) {
				elem = nums[i];
				count = 1;
			}
			else {
				if (elem == nums[i])
					count++;
				else
					count--;
			}
		}
		return elem;
	}
};

除此之外，C++还有一个nth_element函数能够直接把第n大元素放在第n个位置。由于题意多数元素必然多于n/2次，因此出现在第n/2位置的元素必然为多数元素。

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