剑指 Offer 39. 数组中出现次数超过一半的数字
题目描述
数组中有一个数字出现的次数超过数组长度的一半,请找出这个数字。
你可以假设数组是非空的,并且给定的数组总是存在多数元素。
限制:
- 1 <= 数组长度 <= 50000
本题和 leetcode-229. 求众数 II 一样。
哈希
思路
- 统计每个元素的出现次数,找次数超过 n / 2 n/2 n/2 的元素。
class Solution {
public int majorityElement(int[] nums) {
Map<Integer, Integer> map = new HashMap<>();
// 统计次数
for (int i : nums) map.put(i, map.getOrDefault(i, 0) + 1);
// 找出现次数超过数组长度的一半的数字
for (int i : nums) {
if (map.get(i) > nums.length / 2) {
return i;
}
}
return -1; // 不存在
}
}
以上代码中 2 个 for 可以合成一个 for 循环(但是复杂度并没有本质变化)
class Solution {
public int majorityElement(int[] nums) {
int n = nums.length;
Map<Integer, Integer> map = new HashMap<>();
for (int x : nums) {
map.put(x, map.getOrDefault(x, 0) + 1);
if (map.get(x) > n / 2) return x;
}
return -1;
}
}
- 时间复杂度: O ( n ) O(n) O(n)
- 空间复杂度: O ( n ) O(n) O(n)
排序
思路
- 对所有元素排序;
- 则 n u m s [ n u m s . l e n g t h / 2 ] nums[nums.length / 2] nums[nums.length/2] 即为 出现的次数超过数组长度的一半的元素。
class Solution {
public int majorityElement(int[] nums) {
Arrays.sort(nums);
return nums[nums.length / 2];
}
}
- 时间复杂度: O ( n l o g n ) O(nlogn) O(nlogn)
- 空间复杂度:
O
(
1
)
O(1)
O(1) (忽略快排消耗栈空间
O
(
l
o
g
n
)
O(logn)
O(logn))
摩尔投票法 :star:
以上 排序、哈希 在空间上都不是最优的,此类在集合中找 多数元素(众数)
的题使用 摩尔投票法
可以将 空间复杂度降为
O
(
1
)
O(1)
O(1)
参考之前的一篇文章 leetcode-229. 求众数 II
思路 🤔
摩尔投票法 分为2个阶段:
变量定义:设
cand
为“可能”候选人(即,多数元素),count
为cand
的 “可抵消次数”
- 投票阶段(抵消阶段):不相同的元素,则抵消;相同的元素,则累加;
- 当
count == 0
时,说明之前的候选人 c a n d cand cand 对应的 c o u n t count count 都被抵消完事了,此时需要更换候选人; - 比如,给定数组为 [ 1 , 1 , 2 , 2 , 2 ] [1, 1, 2, 2, 2] [1,1,2,2,2],当 i = 4 i = 4 i=4 时 c o u n t = = 0 count== 0 count==0,此时需要更新 c a n d = n u m s [ 4 ] cand = nums[4] cand=nums[4]
- 当
- 计数阶段:最终得到的“可能” 候选者
cand
,不一定是最终 的众数,所以还需要一轮 计算阶段,来判断后选择cand
是不是最终的“众数”- 比如, [ 1 , 2 , 3 ] [1,2,3] [1,2,3] 得到的结果为 c a n d = 3 cand = 3 cand=3、 c o u n t = 1 count = 1 count=1,但是其实这个 n u m s nums nums 中并没有 众数。所以,需要 计数阶段
class Solution {
public int majorityElement(int[] nums) {
int n = nums.length;
int cand = -1;
int count = 0;
// 1、投票阶段
for (int i : nums) {
// 1.1 投票
if (cand == i) { // 相同元素,则累加
count++;
continue;
}
// 1.2 更换候选人
if (count == 0) {
cand = i;
count = 1;
continue;
}
// 1.3 不同元素,则抵消
count--;
}
// 2、计数阶段
int sum = 0;
for (int i : nums) {
if (i == cand ) sum++;
}
if (sum > n / 2) return cand;
else return -1;
}
}
复杂度分析
- 时间复杂度: O ( n ) O(n) O(n)
- 空间复杂度: O ( 1 ) O(1) O(1)
注意⚠️:“投票阶段”三者的顺序不可以改变,否则逻辑则会出现问题
- 即 (1.1)累加判断 (1.2)更换候选人 (1.3)抵消
剑指 Offer 66. 构建乘积数组
题目描述
给定一个数组 A[0,1,…,n-1],请构建一个数组 B[0,1,…,n-1],其中 B[i] 的值是数组 A 中除了下标 i 以外的元素的积, 即 B[i]=A[0]×A[1]×…×A[i-1]×A[i+1]×…×A[n-1]。不能使用除法。
提示:
- 所有元素乘积之和不会溢出 32 位整数
- a.length <= 100000
暴力 TLE
暴力模拟,但是超时了 …
class Solution {
public int[] constructArr(int[] a) {
int n = a.length;
int[] res = new int[n];
for (int i = 0; i < n; i++) {
int mul = 1;
for (int j = 0; j < n; j++) {
if (i != j) {
mul *= a[j];
}
}
res[i] = mul;
}
return res;
}
}
- 时间复杂度:
O
(
n
2
)
O(n^2)
O(n2) (题目数据范围为
1
0
5
10^5
105,所以造成了
TLE
) - 空间复杂度:
O
(
1
)
O(1)
O(1)
上、下三角矩阵 ⭐️
其实,暴力模拟中做了大量重复的计算,所以造成效率很低。
可以通过将其转换为:分别求上、下三角矩阵来进行优化,可以将时间复杂度降为 O ( n ) O(n) O(n)。
- 参考 K佬题解
思路 🤔
- 先求下三角矩阵(从前到后)
r e s [ i ] = 1 ∗ a [ 0 ] ∗ . . . ∗ a [ i − 1 ] res[i] = 1 * a[0] * ... * a[i-1] res[i]=1∗a[0]∗...∗a[i−1] - 再求上三角矩阵(从后向前)
r e s [ i ] ∗ = ( a [ n − 1 ] ∗ . . ∗ a [ i + 1 ] res[i] *= (a[n-1]*..*a[i+1] res[i]∗=(a[n−1]∗..∗a[i+1]
class Solution {
public int[] constructArr(int[] a) {
int n = a.length;
int[] res = new int[n];
int down = 1;
// 下三角
for (int i = 0; i < n; i++) { // 正序
res[i] = down;
down *= a[i];
}
// 上三角
int up = 1;
for (int i = n - 1; i >= 0; i--) { // 逆序
res[i] *= up;
up *= a[i];
}
return res;
}
}
- 时间复杂度: O ( n ) O(n) O(n)
- 空间复杂度:
O
(
1
)
O(1)
O(1)