数组中出现次数超过一半的数字（java版）

【题目描述】数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。

【解题思路1】

先来看一种最简单的解法，算法复杂度为O(n*log(n))

//1.对数组进行排序，然后遍历

//2.遍历过程中，记录当前元素的出现次数，若超过数组长度的一半，即返回该值

//3.若遍历到最后也没有发现符合条件的元素，按照题目要求，返回 0

【源码1】

import java.util.Arrays;
public class Solution {
public int MoreThanHalfNum_Solution(int [] array) {
if(array.length == 0){
return 0;
}
Arrays.sort(array);
boolean flag = false;
int mNum=array[0], sum=0, temp=array[0], len=array.length/2;
for(int a: array){
if(a == temp){
sum++;
mNum = a;
}
if(sum > len ){
flag = true;
break;
}
if(a != temp){

sum = 1;
temp = a;
}
}
if(flag == false){
mNum = 0;
}
return mNum;
}
}

a. sum用来记录当前值出现的次数。若出现当前值变化的情况，需要重置

sum=1

, 注意此时sum为1，不为0。

b. 设置标志位flag，是针对遍历到最后并没有发现符合条件的值的情况。

【解题思路2】在 “思路1” 的基础上做一个小小的改进。

//1.对数组进行排序

//2.假设存在出现次数超过一半的数字target，则其位于中位数的位置上。此时，无论中位数为单个数值，还是为两个数值的平均数，都为该值。因为若数组长度为偶数，中位数取中间两个值的平均数，此时两个值应该是相同的，都等于最后要求的这个数字target。

//3.求得target后，对数组进行一次遍历，计算target出现的次数，若超过一半则返回该值。否则，不存在符合条件的值，返回0。

【源码2】

import java.util.Arrays;

public class Solution {
public int MoreThanHalfNum_Solution(int [] array) {
Arrays.sort(array);
int count=0, len=array.length;
for(int i=0;i<len;i++){
if(array[i]==array[len/2]){
count++;
}
}
if(count>len/2){
return array[len/2];
}else{
return 0;
}
}
}

【解题思路3】最简单直观的考虑。分别计算每个元素出现的次数，取最大值与len/2做比较。时间复杂度为O(n)。

//1.使用hashmap

链接：https://www.nowcoder.com/questionTerminal/e8a1b01a2df14cb2b228b30ee6a92163
来源：牛客网

public class Solution {
public int MoreThanHalfNum_Solution(int [] array) {
HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
for(int i=0;i<array.length;i++){
if(!map.containsKey(array[i])){
map.put(array[i],1);
}else{
int count = map.get(array[i]);
map.put(array[i],++count);
}
}
Iterator iter = map.entrySet().iterator();
while(iter.hasNext()){
Map.Entry entry = (Map.Entry)iter.next();
Integer key =(Integer)entry.getKey();
Integer val = (Integer)entry.getValue();
if(val>array.length/2){
return key;
}
}
return 0;
}

a. 使用迭代器iterator，加快遍历速度。

【解题思路4】该思路来自剑指offer的解法二，称为“打擂法”，也叫“守阵地思想”。若数组中有一个数字出现次数超过一半，则它出现的次数超过了其他所有数字出现次数的总和。算法复杂度为O(n)。

//1. 遍历数组，同时维护两个值：一个是数组中的一个元素e，另一个是次数count。

//2. 遍历过程中，若下一个元素和之前保存的e不相同，则次数count-1。若相同，则count+1。

//3. 若出现次数为零的情况，则e需要存储下一个数字，并把次数count=1。

//4. 若存在符合条件的元素，最后一次把次数置为1的数字即要找的目标值。否则，返回0。

//5. 验证最后维护的元素e，出现次数是否超过一半。

【源码4】

public class Solution {
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;
}
}

【解题思路5】该思路来自剑指offer第一种解法。该解法会改变原数组。

//1. 若有一个数字出现次数超过了一半，则排序之后位于数组中间的那个数字就是要求的值。

//2. 在随机快速排序算法中，先在数组中随机选一个数字，调整数组中数字的顺序。使得比选中的数字小的数位于其左边，比选中的数字大的数字位于其右边。

//3. 如果这个选中的数字的下标刚好是n/2，则这个数字就是数组的中位数。如果它的下标比n/2大，则中位数应该位于其左边，继续在左边查找。如果它的下标比n/2小，则中位数应位于其右边，继续在右边查找。

【源码5】

链接：https://www.nowcoder.com/questionTerminal/e8a1b01a2df14cb2b228b30ee6a92163
来源：牛客网

public class Solution {
public int MoreThanHalfNum_Solution(int [] array) {
if(array==null||array.length==0)
return 0;
int middle=array.length>>1;
int start=0;
int end=array.length-1;
int index=Partition(array,start,end);
while(index!=middle){
if(index>middle){
end=index-1;
ndex=Partition(array,start,end);
}else{
start=index+1;
index=Partition(array,start,end);
}
}
int result=array[middle];
if(!CheckMoreThanHalf(array,result))
result=0;
return result;
}

public static boolean CheckMoreThanHalf(int array[],int number){
int times=0;
for(int i=0;i<array.length;++i){
if(array[i]==number)
times++;
}
boolean isMoreThanHalf=true;
if(times*2<=array.length){
isMoreThanHalf=false;
}
return isMoreThanHalf;
}

public static int Partition(int array[],int start,int end){
int pivotkey=(int)start+(int)Math.random()*(end-start);
while(start<end){
while(start<end&&array[end]>=array[pivotkey])
end--;
int temp=array[start];
array[start]=array[end];
array[end]=temp;
while(start<end&&array[start]<=array[pivotkey])
start++;
temp=array[start];
array[start]=array[end];
array[end]=temp;
}
return start;
}
}