查找整型数组里出现频率最高的数字的最佳JAVA实现

来源：互联网发布：乐乎网站编辑：程序博客网时间：2024/05/21 20:26

package test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
/**
* 查找整型数组里出现频率最高的数字的最佳JAVA实现。
*
* @author
*/
public class HelloWindowExample {
public static void main(String[] args) {
test1();
test2();
testLaoZiZhu();
testLaoZiZhuCounter();
testLaoZiZhuCounter2();
}
/**
* 方法1
* 一个数组记录了每个数字出现的次数，长度和原始数组相同。
* 每个数组，向前查找相同的数字，如果找到则当前的次数等于上次的次数+1
* 如果没找到，则当前数字的次数为1.
*
* [1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
* [1, 2, 0, 0, 0, 0, 0, 0, 0, 0]
* [1, 2, 1, 0, 0, 0, 0, 0, 0, 0]
* [1, 2, 1, 3, 0, 0, 0, 0, 0, 0]
* [1, 2, 1, 3, 1, 0, 0, 0, 0, 0]
* [1, 2, 1, 3, 1, 4, 0, 0, 0, 0]
* [1, 2, 1, 3, 1, 4, 2, 0, 0, 0]
* [1, 2, 1, 3, 1, 4, 2, 3, 0, 0]
* [1, 2, 1, 3, 1, 4, 2, 3, 4, 0]
* [1, 2, 1, 3, 1, 4, 2, 3, 4, 1]
* 5 4
* 3 4
*/
public static void test1() {
int[] ar = { 5, 5, 8, 5, 3, 5, 3, 3, 3, 1 };
int[] fr = new int[ar.length];
int top = 0;
int i, j;
for (i = 0; i < fr.length; i++) {
// 从当前位置向前查找，和当前数字相同的位置
j = i - 1;
while (j >= 0) {
if (ar[j] == ar[i]) {
// 找到了，退出
break;
}
// 否则继续向前找
j--;
}
if (j < 0) {
// 如果没有找到，则设置次数为1
fr[i] = 1;
} else {
// 如果找到了，则次数为上一个的次数+1
fr[i] = fr[j] + 1;
}
// 记录最大的次数
if (fr[i] > top) {
top = fr[i];
}
// System.out.println(Arrays.toString(fr));
}
for (i = 0; i < fr.length; i++) {
if (fr[i] == top)
System.out.println("" + ar[i] + " " + top);
}
}
/**
* 使用列表，在找到重复数据后，删除列表的数据
* 这样下次循环时次数将减少。
* 不过其使用了字符串，效率不是很高，但思路很好。
*/
public static void test2() {
String[] array = { "5", "5", "8", "5", "3", "5", "3", "3", "3", "1" };
List list = Arrays.asList(array);
list = new ArrayList(list);
List outValue = new ArrayList();
int count = 0;
// 循环，直到列表里不再有数据
while (list.size() - 1 > 0) {
// 拿到最后一个数据
String element = (String) list.get(list.size() - 1);
// 计数
int tempCount = 0;
// 向前查找相同的
for (int j = list.size() - 1; j >= 0; j--) {
// 如果找到，则计数加1，然后从列表删除
// 这也是为何要从末尾开始循环的理由
if (element.equals(list.get(j))) {
tempCount++;
list.remove(j);
}
}
// 如果这个计数最大，则更新输出的数据
if (tempCount > count) {
count = tempCount;
outValue.clear();
outValue.add(element);
} else if (tempCount == count) {
// 否则加入到最大数的列表里
outValue.add(element);
}
}
System.out.println("出现频率最高的是:" + outValue + "/n出现了:" + count + "次");
}
/**
* 我的精心设计
* 不使用列表，而是直接用整型数组进行操作，速度最快.
* 思路和前面列表的相同，但不是进行删除，而是将当前位置的数据设置为尾部的数据。
* 等同于数据交换，将不再用的数据移动到尾部就行了.
* 数组的速度比列表要快太多了。
*/
public static void testLaoZiZhu() {
int[] ar = { 5, 5, 8, 5, 3, 5, 3, 3, 3, 1 };
List<Integer> outValue = new ArrayList<Integer>();
int count = 0;
// 这个是剩余可用的总数
int has = ar.length;
int element;
int tempCount;
System.out.println(Arrays.toString(ar));
// 循环，直到列表里不再有数据
while (has > 0) {
// 拿到最后一个数据
element = ar[has - 1];
// 计数
tempCount = 0;
// 向前查找相同的
for (int j = has - 1; j >= 0; j--) {
// 如果找到，则计数加1，然后将数据和末尾交换
// 这也是为何要从末尾开始循环的理由
if (element == ar[j]) {
tempCount++;
// 将当前位置交换为末尾的数据
// 注意末尾数据是动态变化的
ar[j] = ar[has - 1];
has--;
}
}
System.out.println(Arrays.toString(ar));
// 如果这个计数最大，则更新输出的数据
if (tempCount > count) {
count = tempCount;
outValue.clear();
outValue.add(element);
} else if (tempCount == count) {
// 否则加入到最大数的列表里
outValue.add(element);
}
}
System.out.println("出现频率最高的是:" + outValue + "/n出现了:" + count + "次");
}
/**
* 计数法，前提是数字都是正数。
*/
public static void testLaoZiZhuCounter() {
int[] ar = { 5, 5, 8, 5, 3, 5, 3, 3, 3, 1 };
// 找到最大的数
int max = ar[0];
for (int i = 1; i < ar.length; i++) {
if (ar[i] > max) {
max = ar[i];
}
}
// 构建技术数组
int[] vote = new int[max + 1];
int countMax = 0;
// 开始计数
for (int i = 0; i < ar.length; i++) {
vote[ar[i]]++;
if (vote[ar[i]] > countMax) {
countMax = vote[ar[i]];
}
}
// 输出结果
for (int i = 0; i < vote.length; i++) {
if (vote[i] == countMax) {
System.out.print(i + ",");
}
}
System.out.println("出现次数为" + countMax);
}
/**
* 计数法，前提是数字都是正数。
* 支持负数的情况
*/
public static void testLaoZiZhuCounter2() {
int[] ar = { 5, 5, 8, 5, -3, 5, -3, -3, -3, 1 };
// 找到最大的数
int max = ar[0];
int min = ar[0];
for (int i = 1; i < ar.length; i++) {
if (ar[i] > max) {
max = ar[i];
} else if (ar[i] < min) {
min = ar[i];
}
}
// 构建技术数组
int[] vote = new int[max - min + 1];
int countMax = 0;
// 开始计数
for (int i = 0; i < ar.length; i++) {
// 调整
vote[ar[i] - min]++;
if (vote[ar[i] - min] > countMax) {
countMax = vote[ar[i] - min];
}
}
// 输出结果
for (int i = 0; i < vote.length; i++) {
if (vote[i] == countMax) {
System.out.print((i + min) + ",");
}
}
System.out.println("出现次数为" + countMax);
}
}