给一个长度为 n 的数组,数组中有一个数字出现的次数超过数组长度的一半,请找出这个数字。
例如输入一个长度为9的数组[1,2,3,2,2,2,5,4,2]。由于数字2在数组中出现了5次,超过数组长度的一半,因此输出2。
数据范围:
,数组中元素的值
要求:空间复杂度:
,时间复杂度
保证数组输入非空,且保证有解
[1,2,3,2,2,2,5,4,2]
2
[3,3,3,3,2,2,2]
3
[1]
1
import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
*
*
* @param numbers int整型一维数组
* @return int整型
*/
public int MoreThanHalfNum_Solution (int[] numbers) {
// write code here
int candidate = numbers[0];
int count = 0;
for (int i = 0; i < numbers.length; i++) {
if (count == 0) {
candidate = numbers[i];
count++;
} else {
if (candidate == numbers[i]) {
count++;
} else {
count--;
}
}
}
return candidate;
}
} import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
*
*
* @param numbers int整型一维数组
* @return int整型
*/
public int MoreThanHalfNum_Solution (int[] numbers) {
// write code here
if (numbers == null || numbers.length == 0)
return 0;
if (numbers.length == 1) {
return numbers[0];
}
int count;
for (int i = 0; i < numbers.length; i++) {
count = 0;
for (int j = 0; j < numbers.length; j++) {
if (numbers[i] == numbers[j]) {
count++;
if (count * 2 >= numbers.length)
return numbers[i];
}
}
}
return 0;
}
} public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
*
*
* @param numbers int整型一维数组
* @return int整型
*/
public int MoreThanHalfNum_Solution (int[] numbers) {
// write code here
if(numbers == null){
return 0;
}
int n = numbers.length;
int result = 0;
HashMap<Integer, Integer> map = new LinkedHashMap<>();
for (int i = 0; i < n; i++) {
if (map.containsKey(numbers[i])) {
map.put(numbers[i], map.get(numbers[i]) + 1);
} else {
map.put(numbers[i], 1);
}
}
for (int i = 0; i < n; i++) {
if(map.get(numbers[i]) > n / 2){
result = numbers[i];
break;
}
}
return result;
}
}
import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
*
*
* @param numbers int整型一维数组
* @return int整型
*/
public int MoreThanHalfNum_Solution (int[] numbers) {
// write code here
// 核心思想:创建哈希表统计对应元素的出现次数
// 算法的实践复杂度O(N),空间复杂度O(N)(空间复杂度为O(1)的方法暂时没有想出来)
// 1.创建哈希表
HashMap<Integer, Integer> hm = new HashMap<>();
// 2.遍历数组,记录哈希表
for (int cur : numbers) {
if (hm.containsKey(cur)) {
// 表中记录过当前key
int count = hm.get(cur);
count++;
hm.put(cur, count);
} else {
// 表中没有及路过当前key
hm.put(cur, 1);
}
}
// 3.找到表中出现次数最高的那个key
int max = 0;
int result = numbers[0];
// 3.1 将Map转化成Set,然后使用for遍历,方便使用外部的变量记录结果(匿名内部类不能使用外部变量记录)
Set<Map.Entry<Integer, Integer>> entrySet = hm.entrySet();
for (Map.Entry<Integer, Integer> entry : entrySet) {
if (entry.getValue() > max) {
max = entry.getValue();
result = entry.getKey();
}
}
return result;
}
} import java.util.*;
public class Solution {
public int MoreThanHalfNum_Solution (int[] numbers) {
// write code here
Map<Integer, Integer> map = new HashMap<>();
for (int number : numbers) {
map.put(number, map.getOrDefault(number, 0) + 1);
if(map.get(number) > (numbers.length /2)){
return number;
}
}
return 0;
}
} // hashmap
public int MoreThanHalfNum_Solution1 (int[] numbers) {
HashMap<Integer,Integer> map = new HashMap<>();
for(int i=0;i<numbers.length;i++){
int v = 1;
if(map.containsKey(numbers[i])){
v = map.get(numbers[i]);
map.replace(numbers[i],++v);
}else{
map.put(numbers[i],v);
}
if(v > numbers.length / 2){
return numbers[i];
}
}
return -1;
}
// 投票算法
public int MoreThanHalfNum_Solution (int[] numbers) {
int cond = -1,num = 0;
for(int i=0;i<numbers.length;i++){
if(num == 0){
cond = numbers[i];
num = 1;
}else if(cond == numbers[i]){
num++;
}else{
num--;
}
}
return cond;
} import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
*
*
* @param numbers int整型一维数组
* @return int整型
*/
public int MoreThanHalfNum_Solution (int[] numbers) {
int res = numbers[0];
int count = 1;
for (int i = 1; i < numbers.length; i++) {
if (count == 0) {
res = numbers[i];
}
if (numbers[i] == res) {
count++;
} else {
count--;
}
}
return res;
}
} import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
*
*
* @param numbers int整型一维数组
* @return int整型
*/
public int MoreThanHalfNum_Solution (int[] numbers) {
// write code here
Map<Integer, Integer> valueMap = new HashMap<>();
int half = numbers.length / 2;
for (int i = 0; i < numbers.length; i++) {
int num = numbers[i];
if (valueMap.containsKey(num)) {
valueMap.put(num, valueMap.get(num) + 1);
} else {
valueMap.put(num, 1);
}
if (valueMap.get(num) > half) {
return num;
}
}
return 0;
}
} public class Solution {
public int MoreThanHalfNum_Solution (int[] numbers) {
if (numbers.length == 1) return numbers[0];
// 左右双指针,从两端找,如果两数不同则删去(置-1),相同则跳过
int i = 0;
int j = numbers.length - 1;
int exist_count = numbers.length; // 统计剩余的非-1的数
while (i < j) {
if (exist_count <= 2) break;
if (numbers[i] == numbers[j] || numbers[j] == -1) {
j--;
} else {
numbers[i] = -1;
numbers[j] = -1;
exist_count -= 2; // 两数不同则抵消
i++;
j = numbers.length - 1; // 右端可能有非-1的其它数,所以将右指针重置
}
}
for (int num : numbers) { // 最后剩下的数就是目标数
if (num != -1) return num;
}
return -1;
}
} import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
*
*
* @param numbers int整型一维数组
* @return int整型
*/
public int MoreThanHalfNum_Solution (int[] numbers) {
// write code here
if(numbers == null || numbers.length == 0){
return 0;
}
Map<Integer,Integer> numMap = new HashMap<>();
Integer key = 0;
Integer max = 0;
for(int i = 0; i < numbers.length ; i++){
Integer val = numMap.get(numbers[i]);
if(val == null){
val = 1;
}else{
val = val + 1;
}
if(val > max){
max = val;
key = numbers[i];
}
numMap.put(numbers[i], val);
}
return key;
}
} import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
*
*
* @param numbers int整型一维数组
* @return int整型
*/
public int MoreThanHalfNum_Solution (int[] numbers) {
// write code here
int c = 0;
int nums = numbers.length;
int mid = 1;
Map<Integer,Integer> map = new HashMap();
for (int i = 0; i < nums;i++) {
if (map.containsKey(numbers[i])) {
int b = map.get(numbers[i]) + 1;
if (b > mid) {
mid = b;
}
if (nums/2 < mid) {
return numbers[i];
}
map.put(numbers[i],b);
} else {
map.put(numbers[i],1);
}
}
return numbers[0];
}
} import java.util.HashMap;
import java.util.Map;
public class Solution {
public int MoreThanHalfNum_Solution(int [] array) {
int nums = array.length;
if(nums == 1){
return array[0];
}
Map<Integer,Integer> map =new HashMap<>();
for (int i = 0; i < nums ; i++) {
if(map.containsKey(array[i])){
map.put(array[i],map.get(array[i]) +1);
if(map.get(array[i]) >= nums/2 +1){
return array[i];
}
}else{
map.put(array[i],1);
}
}
return -1;
}
}
public int MoreThanHalfNum_Solution(int [] array) {
int length=array.length;
if(array==null||length<=0){
return 0;
}
if(length==1){
return array[1];
}
int[] tempArray=new int[length];
for(int i=0;i<length;i++){
tempArray[i]=array[i];
}
for(int i=0;i<length;i++){
//后面需要用零来代表抹除数字,所以对0时做特殊处理
if(tempArray[i]==0){
continue;
}
for(int j=i+1;j<length;j++){
if(tempArray[i]!=tempArray[j]&&tempArray[j]!=0){
tempArray[i]=0;//此处用0代表抹去该数字
tempArray[j]=0;
break;
}
}
}
for(int i=0;i<length;i++){
System.out.println(tempArray[i]);
}
//找出未被抹去的数字
int result=0;
for(int i=0;i<length;i++){
if(tempArray[i]!=0){
result=tempArray[i];
break;
}
}
int times=0;
for(int i=0;i<length;i++){
if(result==array[i]){
times++;
}
}
if(times*2<length){
result=0;
}
return result;
}
}
public int MoreThanHalfNum_Solution(int [] array) {
int length=array.length;
if(array==null||length<=0){
return 0;
}
int result=array[0];
int times=1;
for(int i=1;i<length;i++){
if(times==0){
result=array[i];
times=1;
}else{
if(array[i]==result){
times++;
}else{
times--;
}
}
}
times=0;
for(int i=0;i<length;i++){
if(result==array[i]){
times++;
}
}
if(times*2<length){
result=0;
}
return result;
}
}