高手请进，求解一个Java面试编程题！

Question

一个文本文件中约有10万多行的数据，每个数据占一行(数据为一个整数)。要求：统计出总行数，并找出出现次数最多的那个整数。大家帮忙，关键是怎样找出出现次数最多的那个数

Answer 1

以前写过统计一个文件中单词出现的个数和行号的,但是现在不见了
基本思路是使用一个List和一个Set,用List来保存单词(或者你的数字),再用Set来保存每个单词出现的行号,如果不用行号的话就不用Set了，定义一个类
Class YourClass{
   int number; //你的数字
   int count;  //出现个数
}
读文件然后保存吧,如果是数据量很大,可以把文件分拆成几个部分来统计

Answer 2

package test;import java.io.*;
import java.util.ArrayList;public class TestArray { /*
 * public Object []getList(){//获得数组！ try{ ArrayList list=new ArrayList();
 * BufferedReader in = new BufferedReader(new FileReader("d:\\test"));
 * String str; if((str=in.readLine())!=null){ list.add(str);
 *  } return list.toArray();
 * 
 * }catch(Exception e){ e.printStackTrace(); return null; } }
 */
public Object[] getList() {// 测试数组
String[] bb = new String[200];
for (int i = 0; i < bb.length; i++) {
bb[i] = String.valueOf((int) (Math.random() * 50));
}
return bb;
} public int getSize() {// 统计出总行数
Object[] o = getList();
return o.length;
} public int[] getMaxSameNo() {// 找出出现次数最多的那个数组 Object o[] = getList(); int no[] = new int[o.length];
for (int i = 0; i < o.length; i++) {
no[i] = Integer.parseInt((String) o[i]); }
java.util.Arrays.sort(no);// 数组排序
for (int i = 0; i < no.length; i++) {
System.out.println("array[" + i + "]=" + no[i]);
} int maxsum = getSum(no);// 出现次数最多的数到底出现了几次
return getInt(no, maxsum);// 找出出现次数最多的那个数 } public int getSum(int[] no) {// 此方法返回出现次数最多的数到底出现了几次！
ArrayList sumlist = new ArrayList();
int sum = 1;
for (int i = 0; i < no.length - 1; i++) {
if (no[i] == no[i + 1]) {
sum++;// 相临两个相等计数器+1
} else {
// 不相等向集合里加入
sumlist.add(sum);
// 计数器复位继续比较
sum = 1;
continue;
}
}
int max = 0;
for (int i = 0; i < sumlist.size(); i++) {// 此循环取出集合里最大的数！
if (Integer.parseInt(sumlist.get(i).toString()) > max) {
max = Integer.parseInt(sumlist.get(i).toString());
}
}
return max;
} public int[] getInt(int[] no, int a) {// 此方法返回出现次数为a的数组，可能有多个数字出现相同的次数的情况,所以返回的是数组
ArrayList sumlist = new ArrayList();
int sum = 1;
for (int i = 0; i < no.length - 1; i++) {
if (no[i] == no[i + 1]) {
sum++;
} else {
if (sum == a) {
sumlist.add(no[i]);
System.out.println(no[i] + "一共出现了" + a + "次！");
} else {
sum = 1;
continue;
} }
}
int aa[] = new int[sumlist.size()];
for (int i = 0; i < aa.length; i++) {
aa[i] = Integer.parseInt((sumlist.get(i).toString()));
}
return aa; } /**
 * @param args
 */
public static void main(String[] args) {
// TODO 自动生成方法存根
TestArray test = new TestArray();
int count = test.getSize();
System.out.println("一共有" + count + "条记录!");
int[] max = test.getMaxSameNo();
System.out.println("出现次数最多的数为:");
for (int i = 0; i < max.length; i++) {
System.out.print(max[i] + ",");
} }}

Answer 3

另外的思路！将数据写入数据库！用sql语言JDBC

Answer 4

你用数据结构中的链表就可以了三,没读取一个数先遍历链表看存在不,存在就在对应的num++;不存在就新建立一个节点 不过这样效率问题不高哈,没个数据到要重头遍历一次链表

Answer 5

package test;import java.io.*;
import java.util.ArrayList;public class TestArray { /*
 * public Object []getList(){//获得数组！ 
 * try{ ArrayList list=new ArrayList();
 * BufferedReader in =
 *  new BufferedReader(new FileReader("d:\\test"));
 * String str; 
 * if((str=in.readLine())!=null){ 
 * list.add(str);
 *  }
 *   return list.toArray();
 * 
 * }catch(Exception e){
 *  e.printStackTrace(); 
 *  return null; }
 *   }
 */
public Object[] getList() {// 测试数组
String[] bb = new String[200];
for (int i = 0; i < bb.length; i++) {
bb[i] = String.valueOf((int) (Math.random() * 50));
}
return bb;
} public int getSize() {// 统计出总行数
Object[] o = getList();
return o.length;
} public int[] getMaxSameNo() {// 找出出现次数最多的那个数组 Object o[] = getList(); int no[] = new int[o.length];
for (int i = 0; i < o.length; i++) {
no[i] = Integer.parseInt((String) o[i]); }
java.util.Arrays.sort(no);// 数组排序
for (int i = 0; i < no.length; i++) {
System.out.println("array[" + i + "]=" + no[i]);
} int maxsum = getSum(no);// 出现次数最多的数到底出现了几次
return getInt(no, maxsum);// 找出出现次数最多的那个数 } public int getSum(int[] no) {// 此方法返回出现次数最多的数到底出现了几次！
ArrayList sumlist = new ArrayList();
int sum = 1;
for (int i = 0; i < no.length - 1; i++) {
if (no[i] == no[i + 1]) {
sum++;// 相临两个相等计数器+1
} else {
// 不相等向集合里加入
sumlist.add(sum);
// 计数器复位继续比较
sum = 1;
continue;
}
}
int max = 0;
for (int i = 0; i < sumlist.size(); i++) {// 此循环取出集合里最大的数！
if (Integer.parseInt(sumlist.get(i).toString()) > max) {
max = Integer.parseInt(sumlist.get(i).toString());
}
}
return max;
} public int[] getInt(int[] no, int a) {// 此方法返回出现次数为a的数组，可能有多个数字出现相同的次数的情况,所以返回的是数组
ArrayList sumlist = new ArrayList();
int sum = 1;
for (int i = 0; i < no.length - 1; i++) {
if (no[i] == no[i + 1]) {
sum++;
} else {
if (sum == a) {
sumlist.add(no[i]);
System.out.println(no[i] + "一共出现了" + a + "次！");
sum=1;
continue;
} else {
sum = 1;
continue;
} }
}
int aa[] = new int[sumlist.size()];
for (int i = 0; i < aa.length; i++) {
aa[i] = Integer.parseInt((sumlist.get(i).toString()));
}
return aa; } /**
 * @param args
 */
public static void main(String[] args) {
// TODO 自动生成方法存根
TestArray test = new TestArray();
int count = test.getSize();
System.out.println("一共有" + count + "条记录!");
int[] max = test.getMaxSameNo();
System.out.println("出现次数最多的数为:");
for (int i = 0; i < max.length; i++) {
System.out.print(max[i] + ",");
} }}

Answer 6

这代码算长吗？人家项目一个class也有1000行啊！晕！

Answer 7

import java.io.File;
import java.io.RandomAccessFile;
import java.util.ArrayList;
import java.util.Arrays;
public class TestSum {
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
ArrayList<Integer> dataSet = new ArrayList<Integer>(500) ;
File f = new File("存储数据集的文件") ;
RandomAccessFile ras = new RandomAccessFile(f, "r");
String str = ras.readLine();
int count = 0;  // count用来存储数据量
while (str != null) {
dataSet.add(Integer.parseInt(str)) ;
count++ ;          //读取一个数，count++
str = ras.readLine();
}
ras.close();
//读取数据结束
Integer[] a = new Integer[dataSet.size()] ;

a = (Integer[])dataSet.toArray() ;//变成数组存放
Arrays.sort(a);
numSum aa = new numSum(Integer.MIN_VALUE) ;//存储最大的
numSum bb = new numSum(Integer.MAX_VALUE) ;//临时的
for (int i = 0; i < a.length; i++) {
if(a.length - 1 == i)
break ; 
if(a[i] == a[i + 1]){
bb.value = a[i] ;
bb.sum = 1 ;
while(a[i] == a[i + 1]){
// bb.value = a[i] ;
bb.sum ++ ;
i++ ;
if(a.length - 1 == i)
break ; 
}//while
// i -- ;
}//if

if(bb.sum > aa.sum){
aa.sum = bb.sum ;
aa.value = bb.value  ;
}//if

}//for
System.out.println("数据量为：" + count);
System.out.println("最大数为：" + aa.value + " 数的个数为： " + aa.sum);
}//main
}//testSum
class numSum{
int value ;
int sum = 0 ;
public numSum(int value ){
this.value = value ;
this.sum = 0 ;
}
}

Answer 8

上面是我写的一个程序
60多行
基本思路就是：
首先读取数据，因为一行只有一个数据，所以在读取的过程中可以完成两个步骤，1，数据量的计算，每读取一行，count++ ，同时把数据存储到一个链表中，
然后把链表转换为数组，利用Arrays的静态方法sort()完成数组的排序
最后根据排序好的数组计算哪个数出现的最多
最后输出
类numSum可以简单的看作一个结构
主要是存储一个整数和该整数出现的次数
完全可以用两个变量代替

Answer 9

不难啊
我不会编程
也来说说思路从上往下读,举个例子
如果第一行的数字 为10 ,然后记录,10(数字) 1(次数)
然后第二行的数字为5,记录 5  1
第三行的数字又是10 ,然后记录为10 2
.
.
.
.
.
.
最后得到一系列的数字,为A  几次, B 几次,C 几次......
把各个数字的次数相加就是总行数,次数最多的那个数字,就是出现了最多次数的数字.

Answer 10

晕！！
最简单的应该是hashtable将解吸出来的数字加到hashtable里面,其中数字做为key,每加一个数字对应key的value+1（充分利用hashtable 的key不可重复）最后比较value 最大的对应的key就是哪个数了！

Answer 11

最简单的思路是：先找到这些整数中最大的哪个数为m，再根据这个数int[] arts = new int[m]，然后根据行数去循环，每一行的数据n则atrs[n]++;最后arts中最大的对应的下标就是出现次数最多的.这样做最多循环两次，程序就自己搞定，好印象深刻点

Answer 12

先读一行往map 里做为关键字插入!然后判断map的大小！if(map.size()=='map 的原始大小'){这个数出现过 把内容里+1else 没有出现过的}

Answer 13

hash表好实现点吧..10万个数应该也不算太多..汗..而且不是还有重复的么..

Answer 14

有个问题哈,上面两位写的程序我在自己机子上编译出现一个错误
比如说第一位的是这句出现问题:sumlist.add(sum);
它提示:The method add(int, Object) in the type ArrayList is not applicable for the 
 arguments (int)
哪出问题了吗?新人求指教哈

Answer 15

有个问题哈,上面两位写的程序我在自己机子上编译出现一个错误
比如说第一位的是这句出现问题:sumlist.add(sum);
它提示:The method add(int, Object) in the type ArrayList is not applicable for the 
 arguments (int)
哪出问题了吗?新人求指教哈

Answer 16

yvhkpgf
 你的文件有多少数据？

Answer 17

利用Set和Map的特性可以完成,我写的代码如下~请高手指点!!import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;public class StatData { public static void main(String[] args) {
StatData.stat("F:/Data.txt");
} public static void stat(String file) {
FileReader fr = null;
BufferedReader br = null;
Set<Integer> set = new HashSet<Integer>();
Map<Integer,Integer> map = new HashMap<Integer, Integer>();
Integer max = null;
int m = 0;
try {
fr = new FileReader(file);
br = new BufferedReader(fr);
String str = null;
int total = 0;
while((str =br.readLine()) != null) {
int i = Integer.parseInt(str);
boolean flag = set.add(i);
if(flag) {
map.put(i, 1);
} else {
int count = map.get(i).intValue();
count++;
map.put(i, count);
}
total++;
}
System.out.println("数据总共有 " + total + "行");
Object[] obj = set.toArray();
for(int j = 0; j < map.size(); j++) {
int value = map.get((Integer)obj[j]).intValue();
if(value > m) {
max = (Integer)obj[j];
m = value;
}
}
System.out.println("出现次数最多的数为:" + max);
System.out.println("出现了: " + m + "次");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(br != null) br.close();
if(fr != null) fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

Answer 18

导入至数据库用。用group by语句查出即可。

Answer 19

二叉排序树的应用。
数据结构：每个节点两个属性1，value数值；2，count值为等于该value值的数的个数。
实现步骤：1，建一棵空树；2，每读一行数，先找树中是否有等于value值的节点，有则该节点的count加1，否则将数插入树中，使该树仍为二叉排序树，直到遍例完十万多行数；3，对所有节点的count值进行比较，取最大相应的节点value值为所需。

Answer 20

在这里我觉得还是用hash比较好。每一不同的整数有不同的hash值，然后再找最后的就方便多了。

Answer 21

题目出的不好，鬼知道数据重复率高不高啊，Oracle的索引还分好几种呢

Answer 22

这是某搜索公司的面试题吧:)
俺也做过
我的思路是一条一条读,不能一次读那么大的数据量,系统可能承受不了那么大的冲击
同时count++,同时比较该条有没有出现过
然后用个什么东西都可以,记录出现了数及出现的次数
最后再查出出现最多的
好像速度还可以不过最后也没去成那家公司:(

Answer 23

用HashMap
0.3个变量，count=0；记录总行数,maxCountValue,maxCount=0;
1.打开文件(考虑buffer的方式)
2.for（每一行）{
  int tempValue=这一行数据；
  Map中有，+1；
  没有，新增；
  同时记录最后一次加入的次数是否最多的，不用整个完了之后再找一遍  
}

Answer 24

直接导入oracle 一句sql就出来了 

Answer 25

十万行也不算大，其实
粗略估计下，整数*10w  也就是4M的内存，所以完全可以统统读入内存加以处理的。
基本思路就是数组+冲突
 数组包含两个域 ：data 和 selfCount，可以用相邻的奇数和偶数索引表示 
遍历一遍（当然同时要countAll  number）,插入到数组中，当然此处应该使用插入排序的，因为以后要逐个查找匹配（可用折半查找），若有匹配，然后相应的selfCount++，处理下一条；若没有，则插入排序到相应的索引处。直到结束时，遍历一遍数组，去最大的selfCount即可