题目描述：

如何找出数组中重复元素最多的数

思路：

使用Map映射表记录每一个元素出现的次数，然后判断次数大小，进而找出重复次数最多的元素。key表示数组的元素，value表示这个元素在数组中出现的次数。最后对map进行遍历。

代码：

/** 
	 * 使用map(不允许重复的)，key是a中元素的值,value是元素出现的次数
	 * @param a
	 * @return
	 */
	private int findMostFrequentInArray(int[] a) {
		Map<Integer, Integer> map = new HashMap<Integer, Integer>();
		for(int i=0; i<a.length; i++ ){
			if(map.containsKey(a[i])){
				map.put(a[i], map.get(a[i])+1);
			}else{
				map.put(a[i], 1);
			}
		}
		int index=0;//数组中重复元素最多的数
		int val = 0;//最多的次数
		Iterator<Entry<Integer, Integer>> iterator = map.entrySet().iterator();
		while(iterator.hasNext()){
			Entry<Integer, Integer> next = iterator.next();
			int key = next.getKey();
			int value = next.getValue();
			if(value > val){
				index = key;
				val = value;
			}
		}
		return index;
	}

测试代码：

@Test
	public void test1(){
		int[] a = {1,1,1,1,1,2,2,4,4,4,4,5,5,6,6,6};
		System.out.println(findMostFrequentInArray(a));
	}

 

算法思路：

     使用Map映射表存放每一个数据及出现的次数

     再判断次数大小，进而找出重复次数最多的数

     Map取数据常用方法：

    1、先拿到当前map所有的key 根据key迭代出所有的value

Set<Integer> set = map.keySet();  
Iterator<Integer> it = set.iterator();  
while(it.hasNext()){  
    Integer key = it.next();  
    System.out.println("key:" + key + ", value:" + map.get(key));  
}  

     2、  Map.Entry是Map的一个工具类,提供了从map中读取一行数据的读取，一次可以迭代出map集合中的键值对

Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();  
while (it.hasNext()) {  
    Map.Entry<Integer, String> entry = it.next();  
    System.out.println("key:"+entry.getKey() + ", value:"+entry.getValue());  
}  

实现代码：

package JBArray;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

/**
 * 找出数组中重复元素出现最多的数
 * @author Dan
 *
 */
public class findMostFrequenInArray {
	
	/**
	 * 思路描述：
	 * 使用Map映射表存放每一个数据及出现的次数
	 * 再判断次数大小，进而找出重复次数最多的数
	 * 
	 * @param a
	 * @return
	 */
	public static int findMostFrequenInArray(int[] a){
		int result = 0;
		int size = a.length;
		if(size == 0){
			return Integer.MAX_VALUE;
		}
		//记录每个元素出现的次数
		Map<Integer,Integer> m = new HashMap<Integer, Integer>();
		for (int i = 0; i < size; i++) {
			if (m.containsKey(a[i])) {
				m.put(a[i], m.get(a[i])+1);//已有该元素，直接累加
			}
			else{
				m.put(a[i], 1);//插入该元素，次数为1
			}
		}
		//找出出现次数最多的元素
		int most = 0;
		Iterator iter = m.entrySet().iterator();
		while (iter.hasNext()) {
			Map.Entry  entry = (Map.Entry) iter.next();
			int key = (int) entry.getKey();
			int val = (int) entry.getValue();
			if (val>most) {
				result = key;
				most = val;
			}
		}
		return result;
	}
	
	public static void main(String[] args) {
		int[] arr = {1,5,3,3,4,4,4};
		int maxFreNum = findMostFrequenInArray(arr);
		System.out.println(maxFreNum);
	}
	

}


 

在堆区申请一个超级大的一维数组空间，用它的下标存原数组的数。。出现一次对应下标的值+1…觉得这样方便的不然就是不停的遍历…暂时没想到其他办法…就投机一下。
int Find(int *pStr,int len,int *pa)
{
	int i;
	int *p1 = pStr;
	for(i = 0;i<len;i++)
	{
		//printf("=%d=",p1[i]);
		int index = p1[i];
		pa[index]+=1;
		//printf("pa[%d] = %d  ",index,pa[index]);
	}
	int max = pa[0];
	int max1 = 0;
	for(i =0;i<10000000;i++)
	{
		
		if(pa[i]>max)
		{
			max = pa[i];
			max1 = i;
		}
	}
	return max1;
	
}

int main(int argc, char const *argv[])
{
	int *pa = (int *)malloc(sizeof(int)/sizeof(char)*10000000);
	
	
	if(NULL == pa)
	{
		printf("error\n");
	}
	int s[]={1,2,5,3,32,44,3,4,3,9,10,9,9,9,9,99,9};
	int length  = sizeof(s)/sizeof(int);
	int max = Find(s,length,pa);
	printf("max = %d\n",max);
	free(pa);
	pa = NULL;
	if(NULL == pa)
		printf("success\n");
	return 0;
}

方法一：采用一个数字来储存每个数字出现的次数
let a = [1,2,3,3,2,2,3]

let countArr = []; //定义个数组来储存每个数字出现的次数，数组下标是对应的数字

for(let j=0; j<a.length; j++){
  // 判断是否第一次出现
  if(j === a.indexOf(a[j])){
    countArr[a[j]] = 1
  }else{
    countArr[a[j]] = countArr[a[j]] + 1
  }
}

let maxNum = 0 //储存数字的最多次数

for(let i=0; i<countArr.length; i++){
  if(countArr[i] !== undefined && countArr[i] > maxNum){
    maxNum = countArr[i]
  }
}

for(let j=0; j<countArr.length; j++){
  if(maxNum === countArr[j]){
    console.log('出现最多的数字为：',j);
  }
}

方法二：采用一个对象来存储，键表示该数字，值表示给数字出现次数
let a = [1,2,3,3,2,2,3,12,33,12,12,33]
let obj = {} //采用键值对来存储，键表示该数字，值表示给数字出现次数
let maxNum = 0
a.forEach((item,index) => {
  if(a.indexOf(item) == index){
    obj[item] = 1
  }else{
    obj[item] = obj[item] + 1
  }
})
//找出谁是最大值
for(let i in obj){
  if(obj[i] > maxNum){
    maxNum = obj[i]
  }
}
//根据最大值输出对应的数字
for(let j in obj){
  if(obj[j] === maxNum){
    console.log('出现次数最多的数字为',j,' ,次数为',obj[j]);
  }
}