Question

[java]几道java题目，求各位道友助攻！！！！如果答案好的话，再追加分数

JAVA_01. 对整形数据组按照和指定整数的差值大小进行排序，按照差值升序排列返回
题目描述(60分)：
对整形数据组按照和指定整数的差值大小进行排序，按照差值升序排列返回。
要求实现方法： public static int[] calcTimes(int[] num, int value);
【输入】 num：整型数组；
value 指定的整数
【返回】 按照升序返回整型数组，排序按照各个整数和指定整数的差值大小
【注意】只需要完成该函数功能算法，中间不需要有任何IO的输入输出
示例 输入：num = {1,2,3,4,5,10,17,18,19} value = 5
返回：{5,4,3,2,1,10,17,18,19}

JAVA_02. 取出整型数据中出现次数最多的数据，并按照升序排列返回
题目描述(40分)：
取出整型数据中出现次数最多的元素，并按照升序排列返回。
要求实现方法： public static int[] calcTimes(int[] num, int len);
【输入】 num：整型数组；
len 输入的整数个数
【返回】 按照升序排列返回整型数组中出现次数最多的元素
【注意】只需要完成该函数功能算法，中间不需要有任何IO的输入输出
示例 输入：num = {1,1,3,4,4,4,9,9,9,10} len = 10
返回：{4,9}

JAVA_03. 取出整型数据中存在指定整数的数据，并按照升序排列返回
题目描述(附加题 50分)：
取出整型数据中存在指定整数的数据，并按照升序排列返回。
要求实现方法： public static int[] calcTimes(int[] num, int value);
【输入】 num：整型数组；
value 指定的整数
【返回】 按照升序排列返回整型数组中包含指定整数的元素
【注意】只需要完成该函数功能算法，中间不需要有任何IO的输入输出
示例 输入：num = {12345,654123,98764,123654,9876,4,6,97,8,123} value = 123
返回：{123,12345,123654,654123}

Answer 1

码了半个多小时，应该是符合题目需求了，分别使用了冒泡和选择算法。另外结合String和Map一些特性。有问题追问吧，good luck！~
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Algorithm {
/**
* @Description：差值排序使用选择排序算法实现（第一题）
* @param num - 数组
* @param value - 指定值
* @return
* @throws
*/
public static int[] calcTimes1(int[] num, int value) {
for (int i = 0; i < num.length; i++) {
int lowerIndex = i;
// 找出最小的一个索引
for (int j = i + 1; j < num.length; j++) {
if (Math.abs(num[j] - value) < Math.abs(num[lowerIndex] - value)) {
lowerIndex = j;
}
}
// 交换
int temp = num[i];
num[i] = num[lowerIndex];
num[lowerIndex] = temp;
}
for (int i : num) {
System.out.print(i + " ");
}
return num;
}

/**
* @Description：使用冒泡排序，map键值
* @param num
* @param len
* @return
* @throws
*/
public static int[] calcTimes2(int[] num, int len) {
Map<String, Integer> map = new HashMap<String, Integer>();
int count = 1;
int max = 0;
for (int i = 0; i < num.length; i++) {
for (int j = i + 1; j < num.length; j++) {
if (num[i] == num[j]) {
count++;
}
}
if (count > max) {
max = count;
map.clear();
map.put(String.valueOf(num[i]), max);
} else if (count == max) {
map.put(String.valueOf(num[i]), count);
}
count = 1;
}

Set<String> maxs = map.keySet();
System.out.println(maxs);
int[] tempnum = new int[maxs.size()];
int z = 0;
for (String s : maxs) {
tempnum[z] = Integer.parseInt(s);
z++;
}
return tempnum;
}

/**
* @Description：String indexOf判断是否包含，冒泡排序
* @param num
* @param value
* @return
* @throws
*/
public static int[] calcTimes3(int[] num, int value) {
List<Integer> list = new ArrayList<Integer>();
String strValue = String.valueOf(value);
for (int i = 0; i < num.length; i++) {
String strNum = String.valueOf(num[i]);
if (strNum.indexOf(strValue) >= 0) {
list.add(Integer.valueOf(strNum));
}
}
int[] x = new int[list.size()];
int z = 0;
for (int i : list) {
x[z] = i;
z++;
}
for (int i = 0; i < x.length; i++) {
for (int j = i + 1; j < x.length; j++) {
if (x[i] > x[j]) {
int temp = x[i];
x[i] = x[j];
x[j] = temp;
}
}
}
for (int i : x) {
System.out.print(i + " ");
}
return x;
}

public static void main(String[] args) {
int[] num1 = {1,2,3,4,5,10,17,18,19};
System.out.println("----排序按照各个整数和指定整数的差值大小的结果：");
calcTimes1(num1, 5);

int[] num2 = {1,1,3,4,4,4,9,9,9,10};
System.out.println("\n----出现次数最多的结果：");
calcTimes2(num2, 10);

int[] num3 = {12345,654123,98764,123654,9876,4,6,97,8,123};
System.out.println("----升序排列返回整型数组中包含指定整数的元素的结果：");
calcTimes3(num3, 123);
}
}

Answer 2

1、随便写写，所以这个实现的前提是输入的数组长度固定，不固定还要处理。
public static int[] calTimes(int[] ns,int in){
Map<Integer,Integer> m = new HashMap<Integer,Integer>();
List<Integer> l = new ArrayList<Integer>();
for(int i = 0,j=ns.length;i<j;i++){
int temp = ns[i];
int r = Math.abs(temp-in);
m.put(r, temp);
l.add(r);
}
Collections.sort(l);
int[] result = new int[9];
for (int i = 0; i < l.size(); i++) {
result[i]=m.get(l.get(i));
}
return result;
}

public static void main(String[] args) {
// num = {1,2,3,4,5,10,17,18,19} value = 5

int[] a = {1,2,3,4,5,10,17,18,19};
int v = 5;
int[] result = GenericsTest.calTimes(a, v);
for (int i = 0; i < result.length; i++) {
System.out.println(result[i]);
}

追问

谢谢了，写得挺好的，不过要是数组有两个数字相等的话，map的value要变成列表吧。。。能不能看看剩下的题，分不是问题

追答

回答的基础是输入固定，没考虑那么多……

Answer 3

正好无聊...可以mark下，问下 要求什么效率么？还是实现了就行？

追问

实现了就好，谢谢。。