数组面试题： 今天去面试不会啊 郁闷 大哥们帮解决一下

[sgsrhgs]

一个数组，“支配者”是在数组中出现频率超过一半的整数，
例如[3,4,3,2,-1,3,3,3]数值“3”出现过5次，5除以8大于0.5
所以数值“3”是一个支配者；
而在这个数组中的支配者出现在数组下标[0,2,4,6,7]
写一个函数，在给定的整数数组中找出支配者所在的任意一个数组下标，如果一个数组中没有支配者返回-1；

[Friend_NO1]

mark

[鱼C缸]

学习中

[mdjz]

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ControlNum {

	public static void main(String[] args) {
		int[] data = { 1, 3, 3, 4, 5, 6, 3, 3, 3, 3 };
		Iterator itor = findController(data).iterator();
		while (itor.hasNext()) {
			System.out.print(itor.next() + " ");
		}
	}

	public static List<Integer> findController(int[] data) {
		List<Integer> rlist = null;
		List<Integer> list = new ArrayList<Integer>();
		final double x = 0.5;
		for (int i = 0; i < data.length; i++) {
			int count = 0;
			list.removeAll(list);
			for (int j = i; j < data.length; j++) {
				if (data[i] == data[j]) {
					count++;
					list.add(j);
				}
			}
			if (count / (double)data.length > x) {
				rlist = list;
				break;
			} else {
				list.removeAll(list);
				list.add(-1);
				rlist = list;
			}
		}
		return rlist;
	}
}

[guiqiping]

高人真多啊。学习了。

[qiqushushi]

受教了，高手云集阿！！！

[zhulin10541]

这题有那么难么？
两个循环可以使时间在2n以内的吧

[JamesLiu]

个人解法，有点烦

import java.util.*;
public class Test {
	@SuppressWarnings("unchecked")
	public static void main(String[] args) {
		Map<Integer, List> listNum = new HashMap<Integer, List>();
		int[] num = {3,4,3,2,-1,3,3,3};
		//		用来存储数字的信息,首位置用来记录出现次数,
		//		后面用来记录出现位置下标
		for(int i=0; i<num.length; i++) {		
			//判断listNum里面有这个值
			if(listNum.get(num[i]) != null) {
				//如果有在原来的基础上values加1即出现了几次
				List<Integer> listTemp = (List)listNum.get(num[i]);
				listTemp.add(i);
				listNum.put(num[i], listTemp);
			} else {
				ArrayList<Integer> list = new ArrayList<Integer>();
				list.add(i);
				listNum.put(num[i], list);
			}
		}
		
		//下面是遍历 
		Set set = listNum.entrySet();
		Iterator it = set.iterator();
		int result = -1;
		while(it.hasNext()) {
			Map.Entry entry = (Map.Entry) it.next(); 
			Object key = entry.getKey();
			Object value = entry.getValue();
			List listTemp = (List)value;
			if(listTemp.size() > num.length/2.0 ) {
				System.out.print((Integer)key + 
						"是支配者,出现了"  + listTemp.size() + "次");				
				result = 1;//找到支配者
				Iterator itList = listTemp.iterator();
				while(itList.hasNext()) {
					System.out.print("\t" + (Integer)itList.next());
				}
			} 
		}
		if(result == -1) {
			System.out.println("未找到支配者");
		}
	}
}

[qx8668]

package test;

import java.util.*;

public class TestHashMap {
	public static void main(String[] args) {
		HashMap<Integer, Integer> c = new HashMap<Integer, Integer>();
		// TestHashMap c = new TestHashMap();
		int[] a = new int[] { 3, 4, 6, 2, -1, 3, 3, 3, 3, 2, -1, 6, 3, 3, 3 };
		int s = 1;
		for (int i = 0; i < a.length; i++) {
			if (!c.containsKey(a[i])) {
				c.put(a[i], s);
				for (int j = i + 1; j < a.length; j++)
					if (a[i] == a[j]) {
						s++;
						c.put(a[i], s);
					}
			}
			s = 1;
		}
		System.out.println(c.entrySet());
		System.out.println(c.values());
		int max = 0, temp = 0, j = 0, value = 0;
		Iterator<Integer> it = c.keySet().iterator();
		while (it.hasNext()) {
			temp = it.next();// 得键
			j = c.get(temp);// 得值
			if (max < j) {
				max = j;
				value = temp;
			}
		}
		System.out.println("出现的次数" + max + " " + "数组上的值" + value);

		if ((double) max / a.length < 0.5)
			System.out.println("没有支配者");
		else {
			System.out.println("数组上的位置：");
			for (int i = 0; i < a.length; i++)
				if (a[i] == value)
					System.out.print(" "+i);}
	
	}

}

菜鸟也来凑热闹~~

[scarlet365]

public class SearchInt {

	public static void main(String[] args) {
		searchInt(new int[]{2,1,2,3,2,2,3,1,2,2});
	}
	private static void searchInt(int[] testArray){
		int elementCount = 0;
		int dominator = -1;
		ArrayList indexList = new ArrayList();
		int[] sortArray = new int[testArray.length];
		System.arraycopy(testArray, 0, sortArray, 0, testArray.length);
		Arrays.sort(sortArray);
		for(int i=0;i<sortArray.length;i++){
			if(!(sortArray.length==(i+1)) && sortArray[i]==sortArray[i+1]){
				elementCount++;
			}else{
				if(elementCount>sortArray.length>>1){
					dominator = sortArray[i];
					break;
				}
			}
		}
		for(int i=0;i<testArray.length;i++){
			if(testArray[i]==dominator)
				indexList.add(new Integer(i));
		}
		System.out.println(new StringBuffer("支配者-->").append(dominator).append("\t下标为:").append(indexList));
	}
}

环境是1.4所以用了StringBuffer

[jackychen_king]

我个人认为可以便利一次解决所有问题，在循环的过程及确定超限和最大两个要求。思路我明天在贴上来，今天给大家一个小提示，就是多有变量来保留必要的信息。达到循环一次，得到结果。

[lang3879]

支持6楼

[zjhlht]

学习了~~~~~

[wclszh]

public class 支配数 {
//声明一个方法参数是一个数组，返回的是一个支配数和下表位置
public static String getnumber(int[] a){

for(int i=0;i<a.length;i++){
int d=1;
StringBuffer s=new StringBuffer(i+"");
for(int j=i+1;j<a.length;j++){
if(a[i]==a[j]){
d++;
s.append(","+j);
}
}
if(d>a.length/2)
return "支配书为："+a[i]+"下表为"+s;
}
return "-1";
}
public static void main(String[] args){
//定义一个数组，最为方法的参数
int []s={1,2,3,4,5,2,4,2,5,2,62,72,2,2,2,2,2,2};
//调用函数获得支配数
System.out.println(getnumber(s));
}
}

[jackychen_king]

int[] src={3,4,3,2,-1,3,3,3};


HashMap big=new HashMap();// 保存最大记录
HashMap others=new HashMap();// 保存下表信息

// 循环处理数据
for(int i=0;i<src.length;i++)
{
String key=""+src[i];
if(others.containsKey(key))
{
// 将下标保存到队列中
ArrayList al=(ArrayList)others.get(key);
al.add(""+i);
}else
{
// 添加新的元素同时保存 下标信息
ArrayList al=new ArrayList();
al.add(""+i);
others.put(key, al);
}

// 当前处理对象
ArrayList al=(ArrayList)others.get(key);
if(big.size()>0)
{ // 获取当前认可的 下标信息
ArrayList val=(ArrayList)big.values().toArray()[0];
System.out.println("\n ==[key:"+key+"]"+al+"");
if(val.size()<al.size())
{
// 比对下标长度，存在更长的下标，则替换当前的最大元素
System.out.println("1--[key:"+big.keySet()+"]"+val+"");
big=new HashMap();
big.put(key, new ArrayList(al));
}else if(val.size()==al.size())
{
// 比对下标长度，存在相同的下标，则增加最大元素个数，理论分析应该不存在两个这样的数。 应为 2*0.5 ==1 啦
// 但是保存了最大下标长度的元素。
System.out.println("2-[key:"+big.keySet()+"]"+val+"");
big.put(key, new ArrayList(al));
}
}else
{
big.put(key, al);
}
}

ArrayList al=(ArrayList)big.values().toArray()[0];
System.out.println("src="+ src.toString());

if(al.size()*0.1*10/src.length > 0.5)
{//对比门限值,门限值小于 0.5 则可以存在多个最大元素。
for(Object o:big.keySet())
{
ArrayList al1=(ArrayList)big.get(o);
System.out.println("[key:"+o+"]"+al1+"");
}
}
else
{// 没有支配数，输出 null
System.out.println("null:-1");
}

[henry_fuzr]

先排序 再用前后相减，效率会比较高。

用TreeMap好像比较合适。

[chen2319]

我占个位子先~

[deliangsang]

hehe,凑凑热闹！

[zhuhecool]

           import java.util.ArrayList;

	   public static Object test(int[] arr){				
		
		double length = arr.length;
		if(length==0.0){
			return new Integer(-1);
		}
			
		for(int i = 0 ;i < length; i ++){
		    int count = 0 ;                 //出现个数
		    ArrayList list = new ArrayList();//存放下标
		    
		    for(int j =i ;j<length; j ++){ //循环比较
		     if(arr[i] == arr[j]){
			count ++;
			list.add(j);
		       }			 	
		     }
		 
		    if((count/length)>=0.5){
		     return list.toString(); 
		    }
		}
	      return new Integer(-1);
	}

[zhuhecool]

修改下

for(int i = 0 ;i < lengh/2 + 1; i ++)  //只查一半的元素就可以了。
if((count/length)>0.5)                 //大于0.5
		   
	

[lidandan04]

学习。。。。