剑指39_数组出现次数超过一半的数字

public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        if(array.length<=0)
            return 0;
        int start = 0;
        int length = array.length;
        int end  = length-1;
        int middle = length>>1;
        int index = Partition(array,start,end);
        while(index!=middle){
            if(index>middle){
                index = Partition(array,start,index-1);
            }
            else{
                index = Partition(array,index+1,end);
            }
        }
        int result = array[middle];
        int times = 0;
        for(int i=0;i<length;++i){
            if(array[i] == result)
                times++;
        }
        if(times*2<length){
            System.out.println(times);
            return 0;
        }else{
            return result;
        }
    }
    public int Partition(int[] arr,int low,int high){  //这个要求倒序排列？
        int temp=arr[low]; 
        while(low<high){ 
            while(arr[high]<=temp&&high>low) 
                --high; 
            arr[low]=arr[high]; 
            while(arr[low]>=temp&&low<high) 
                ++low; 
            arr[high]=arr[low]; 
        } 
        arr[high]=temp; 
        return high;         
    }
}

找到数组中第len/2大的数字，如果改数字出现的次数超过len/2那么就是该数字，如果没有返回0。利用快排的思想找第len/2的数字。

import java.util.*;
public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        if(array.length<=0) {
            return 0;
        }
        int len=array.length;
        HashMap<Integer,Integer> map=new HashMap<Integer,Integer>();
        for(int i=0;i<len;i++) {
            if(!map.containsKey(array[i])) {
                map.put(array[i], 1);
            }else {
                int cout=map.get(array[i]);
                map.put(array[i], ++cout);
            }
        }
        Iterator iter=map.entrySet().iterator();
        while(iter.hasNext()) {
            Map.Entry<Integer, Integer> it=(Map.Entry<Integer, Integer>)iter.next();
            Integer k=(Integer)it.getKey();
            Integer v=(Integer)it.getValue();
            if(v>len/2) {
                return k;
            }
        }
        return 0;
    }
}

利用hashmap来获取超过一半次数的数字，hashmap的遍历。

Iterator iter=map.entrySet().iterator();

while(iter.hasNext()){

Map.Entry it=(Map.Entry) iter.next();

Integer k=it.getKey();

}

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

直接排序，之后取中间元素。

import java.util.Arrays; 
public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
		if(array==null||array.length<=0){
            return 0;
        }
        int result=array[0];
        int len=array.length;
        int times=1;
        for (int i=1;i<len;i++){
            if(times==0){
                times=1;
                result=array[i];
                //要找的数字比其他数字的总和都还要多，那么我们要找的数字肯定是最后一次设为1的数字。
            }else if(array[i]==result){
                times++;
            }else{
                times--;
            }
        }
        int time=0;
        for (int i=0;i<len;i++){
            if(array[i]==result){
                time++;
            }
        }
        if(time*2>len){
            return result;
        }
        return 0;  
    }
}

利用数组的特性，要找的数字出现的次数超过数组长度的一半，我们遍历数组的时候保存两个值，一个是数组的值，一个是该值出现的次数，如果下次遍历的数字和上次值相同那么times就加1，如果不同那么减1。如果当times为0那么就重新设置result。

我们要找的数字肯定是最后一次time设为1的数字。