java 数组求最小的三个值，并且考虑平手

Posted 2023-05-01

假设一个数组有6个整数，选出最小的3个值，并考虑平手。例如3，3,4,4,5,5，输出是最小的是1号，2号，数值是3，第二小的是3号，4号，数值为4。例如，3,4,4,5,5,5，输出，最小的是1号，数值为3，第二小的是2号，3号，数值为4.（因为已经有3个数，所以不考虑后面的，类似体育比赛成绩排名次）
可能我之前没说清楚，实际上是这样一个场景，6个运动员参加跑步比赛，每个运动员会在范围内随机生成一个成绩（时间），当然成绩数值越小越好，所以6个成绩组成一个数列，我要取最小的三个值。用array.sort的话，第一，无法处理平局的情况。第二，重新排序后的index被打乱，比如可能1号运动员的成绩在新的数列里面被排在了3号位，那样我就没办法知道选出来的成绩到底是属于哪个运动员的。

public static void main(String[] args)

try
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
int[] num1=new int[6];
int[] num2=new int[6];
String a;
for(int i=0; i < 6; i++)
System.out.println("请输入第" + (i + 1) + "个元素");
a=br.readLine();
num2[i]=Integer.parseInt(a);
num1[i]=Integer.parseInt(a);

StringBuilder result=new StringBuilder();
result.append("最小的是");
Arrays.sort(num1);
int rank=1;
int min=0;
int count=0;
for(int i=0; i < 6 && rank <= 3; i++)
if(min != num1[i] &&count<=3)
for(int k=0; k < 6; k++)
if(num1[i] == num2[k])
if(min != num2[k])
min=num2[k];
rank++;

result.append(k + 1).append("号,");
count++;


result.append("数值是：").append(num1[i]).append(";");
if(rank <= 3 &&count<=3)
result.append("第").append(rank).append("小的是");




System.out.println(result);
catch(IOException e)
e.printStackTrace();

参考技术A 终于做出来了，没进行优化，见谅！

public static void main(String[] args)
//int[] arr = 2,3,4,2,5,3;
int[] arr = 3,4,4,5,5,5;
int[] arr2 = 0,0,0,0,0,0;
for(int i = 0;i < 6; i++)
arr2[i] = arr[i];

Arrays.sort(arr2);
String first = "";
String second = "";
String third = "";
boolean flag1 = false;
boolean flag2 = false;
boolean flag3 = false;
for(int i = 0; i < arr.length; i++)
if(arr[i] == arr2[0] && !flag1)
first += (i + 1) +"号";
flag1 = true;
continue;

if(arr[i] == arr2[1] && !flag2)
flag2 = true;
if(arr[i] == arr2[0])
first += ("," + (i + 1))+"号";
else
second += (i + 1)+"号";

continue;

if(arr[i] == arr2[2] && !flag3)
flag3 = true;
if(arr[i] == arr2[0])
first += (","+ (i + 1))+"号";
else if(arr[i] == arr2[1])
second += (","+ (i + 1))+"号";
else
if("".equals(second))
second += (i + 1)+"号";
else
third += (i + 1)+"号";




System.out.println("最小的号为:"+first+" 数值为:"+ arr[Integer.parseInt(first.substring(0,1))-1]);
if(!"".equals(second))
System.out.println("第二小号为:" + second +" 数值为:" + arr[Integer.parseInt(second.substring(0,1))-1]);

if(!"".equals(third))
System.out.println("第三小号为:" + third +" 数值为:" + arr[Integer.parseInt(third.substring(0,1))-1]);



第一个int[] arr = 2,3,4,2,5,3;的输出是：
最小的号为:1号,4号 数值为:2
第二小号为:2号 数值为:3

第二个int[]arr = 3,4,4,5,5,5;的输出是：
最小的号为:1号 数值为:3
第二小号为:2号,3号 数值为:4追问

恩好的，谢谢

本回答被提问者采纳 参考技术B 这个简单几行代码就OK了

int s[]=3,3,4,4,5,5;
Arrays.sort(s);
for (int i = 0; i < 3; i++)
System.out.print(s[i]);
追问

我知道这个是升序排列，但是升序排列以后的index和原数列的index不一样，而且你这样也没办法处理平局的情况啊。

追答

嗯 重新看了下你的问题，大概已经了解了

参考技术C 楼上正解 参考技术D 很简单啊，先按从小到大排序，然后按顺序输出前三个元素就可以了。
还要代码吗？追问

如何处理平局的情况呢，如何知道成绩对应的运动员。原数列里面a[0] 对应1号运动员，a[1]=对应2号运动员，以此类推。 选出成绩后，我如何能够打印出，第一名是xx号运动员，成绩为xxx。第二名为x号运动员，成绩为xxx。

最适合freshman的Java习题集数组

1. 求数组的平均值
2. 数组所有元素之和
3. 改变原有数组元素的值
4. 打印数组
5. 创建的数组，并且赋初始值
6. 存在连续三个奇数的数组
7. 多数元素
8. 只出现一次的数字
9. 两数之和
10. 冒泡排序
11. 数组是否有序
12. 二分查找
13. 数组的拷贝
14. 数组转字符串

---

1.求数组的平均值

实现一个方法 avg, 以数组为参数, 求数组中所有元素的平均值(注意方法的返回值类型).

public class array 
    //基于数组的日常练习
    public static void main(String[] args) 
        //求数组的平均值
        //实现一个方法 avg, 以数组为参数, 求数组中所有元素的平均值(注意方法的返回值类型).
        int[] arr = 1,9,3,5,4;
        System.out.println(arrAvg(arr));
    
    //先得定义一个数组  遍历数组 求数组长度 求个元素和  然后和/长度=平均值
    public static int arrSum(int[] arr)
        int ret = 0;
        for (int i = 0; i < arr.length; i++) 
            ret += arr[i];
        
        return ret;
    
    public static double arrAvg(int[] arr)
        double ret = 0.0;
        double sum = arrSum(arr);
        ret = sum / arr.length;
        return ret;
    

 

2.数组所有元素之和

实现一个方法 sum, 以数组为参数, 求数组所有元素之和.

public class array 
    public static void main(String[] args) 
        int[] arr = 1,9,3,5,4;
        //2.数组所有元素之和
        System.out.println(arrSum(arr));//22
    
    public static int arrSum(int[] arr)
        int ret = 0;
        for (int i = 0; i < arr.length; i++) 
            ret += arr[i];
        
        return ret;
    

3.改变原有数组元素的值

实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素 乘以 2 , 并设置到对应的数组元素上. 例如 原数组为 1, 2, 3, 修改之后为 2, 4, 6

public class array 
    public static void main(String[] args) 
//        int[] arr = new int[3];
//        arr[0]=1;
//        arr[1]=2;
//        arr[2]=3
        int[] arr = 1,2,3;//定义一个数组，并初始化
        int[] ret = transform(arr);
        printArr(arr);
        System.out.println();
        printArr(ret);
    
    //打印数组元素
    private static void printArr(int[] arr)
        for (int i : arr)  //不改变数组内部元素
            System.out.print(i + " ");
        
    
    public static int[] transform(int[] arr)
        int[] ret = new int[arr.length] ;  //新创建一个数组，跟原数组等长，不改变原数组元素
        for (int i = 0; i < arr.length; i++) 
            ret[i] = arr[i]*2;
        
        return ret;
    

4.打印数组

实现一个方法 printArray, 以数组为参数, 循环访问数组中的每个元素, 打印每个元素的值.

public class array 
    public static void main(String[] args) 
        int[] arr = 1,9,3,5,4;
        String ret = arrPrint(arr);
        System.out.print(ret);//[1,9,3,5,4]
    
//    实现一个方法 printArray, 以数组为参数,
//    循环访问数组中的每个元素, 打印每个元素的值.
    public static String arrPrint(int[] arr)
        String ret = "[";
        for (int i = 0; i < arr.length; i++) 
            ret+=arr[i];
            if (i != arr.length-1) // i < arr.length-1
                ret += ",";
            
        
        ret += "]";
        return ret;
    

 

 5.创建的数组，并且赋初始值

创建一个 int 类型的数组, 元素个数为 100, 并把每个元素依次设置为 1 - 100

import java.util.Arrays;

public class array 
    public static void main(String[] args) 
        int[] a=new int[100];
        setNumber(a);
        System.out.println(Arrays.toString(a));
    
//创建一个 int 类型的数组, 元素个数为 100, 并把每个元素依次设置为 1 - 100
    public static int[] setNumber(int[] arr)
        for (int i = 0; i < 100; i++) 
            arr[i] = i+1;
        
        return arr;
    

6.存在连续三个奇数的数组

给你一个整数数组arr，请你判断数组中是否存在连续三个元素都是奇数的情况：如果存在，请返回 true ；否则，返回 false 。

示例 1：输入：arr = [2,6,4,1]                         输出：false

解释：不存在连续三个元素都是奇数的情况。

示例 2：输入：arr = [1,2,34,3,4,5,7,23,12]     输出：true

解释：存在连续三个元素都是奇数的情况，即 [5,7,23] 。

public class array 
    public static void main(String[] args) 
        int[] a1 = 2,6,4,1;
        numOdd(a1);
        int[] a2 =1,2,34,3,4,5,7,23,12;
        numOdd(a2);
    
//6.给你一个整数数组arr，请你判断数组中是否存在连续三个元素都是奇数的情况：
// 如果存在，请返回true；否则，返回false。
    public static int numOdd(int[] arr)
        int count = 0;
        for (int i = 0; i < arr.length-2; i++) 
            if(arr[i]%2==1 && arr[i+1]%2==1 && arr[i+2]%2==1)
                count++;
            
        
        if (count!=0)
            System.out.println(true);
         else
            System.out.println(false);
        
        return count;
    

7.多数元素

给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 n/2 的元素。你可以假设数组是非空的，并且给定的数组总是存在多数元素。

示例 1：  输入：[3,2,3]                输出：3

示例 2： 输入：[2,2,1,1,1,2,2]     输出：2

import java.util.Arrays;

public class array 
    public static void main(String[] args) 
        System.out.print("arr1的多数元素为：");
        int[] arr1 = 3,2,3;
        System.out.print(searchMost(arr1));
        System.out.print("\\narr2的多数元素为：");
        int[] arr2 = 2,2,1,1,1,2,2;
        System.out.print(searchMost(arr2));
    
//给定一个大小为 n的数组，找到其中的多数元素。多数元素是指在数组中出现次数
//大于n/2的元素。你可以假设数组是非空的，并且给定的数组总是存在多数元素。
    /**
     * 将数组排序，则中间的那个元素一定是多数元素
     * 该代码的时间复杂度为O（NlogN）
     * @param arr 整形数组
     * @return
     */
    public static int searchMost(int[] arr)
        Arrays.sort(arr);  //对数组元素排序
        return arr[arr.length/2];
    

8.只出现一次的数字

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

示例 1:  输入: [2,2,1]              输出: 1

示例 2:  输入: [4,1,2,1,2]        输出: 4

public class array 
    public static void main(String[] args) 
        int[] arr1 = 2,2,1;
        System.out.println(searchOne(arr1));
        int[] arr2 = 4,1,2,1,2;
        System.out.println(searchOne(arr2));
    
//8.给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均
//出现两次。找出那个只出现了一次的元素。
//异或操作 —— 任何数异或0都等于任何数  
    public static int searchOne(int[] arr)
        int temp = 0;
        for (int i = 0; i < arr.length; i++) 
            temp^=arr[i];
        
        return temp;
    

9.两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。

示例 ：

输入：nums = [2,7,11,15], target = 9    输出：[0,1]

解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

public class array 
    public static void main(String[] args) 
        int[] nums = 2,7,11,15;
        searchSum(nums,9);
    
//9.给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出
// 和为目标值 target的那两个整数，并返回它们的数组下标。你可以假设每种
// 输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。你可
// 以按任意顺序返回答案。
// target = nums[i] + nums[j]   ——>return   i , j

    public static int searchSum(int[] nums, int target)
        for (int i = 0; i < nums.length; i++) 
            for (int j = 1; j < nums.length; j++) 
                if (target == nums[i]+nums[j])
                    System.out.print("["+i+","+j+"]");//单纯的控制输出格式
                
            
        
        return target;
    

10.冒泡排序

给定一个整型数组, 实现冒泡排序(升序排序)

public class array 
    public static void main(String[] args) 
//10.冒泡排序  升序排序
//双重循环
        int[] arr = 1, 8, 5, 0, 3, 7, 4;
//        外层循环控制 冒的轮数
        for (int i = 0; i < arr.length / 2; i++) 
//  内层循环控制相邻两个数，若前一个数大于后一个数 则交换两数
//   PS: j的越界问题
            for (int j = 0; j < arr.length - i-1; j++) 
                if (arr[j] > arr[j + 1]) 
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                
            
        
        System.out.println("升序排序为：");
        for (int i = 0; i < arr.length; i++) 
            System.out.print(arr[i]+" ");  //0 1 3 4 5 7 8 
        
    

 

 11.数组是否有序

给定一个整型数组, 判定数组是否有序（递增）

public class array 
    public static void main(String[] args) 
        int[] arr1 = 1,2,3,4,5,6,7;
        System.out.println(arryJudge(arr1));
        int[] arr2 = 3,6,2,5,1,4;
        System.out.print(arryJudge(arr2));
    
//给定一个整型数组, 判定数组是否有序（递增）
    public static boolean arryJudge(int[] arr)
        for (int i = 0; i < arr.length-1; i++) 
            if (arr[i] > arr[i+1])
                return false;
            
        
       return true;
    

 

12.二分查找

给定一个有序整型数组, 实现二分查找

public class array 
    public static void main(String[] args) 
        int[] arr = 1,3,5,7,9,11,13,17;
        System.out.println(searchBinary(arr,2));  //-1
        System.out.println(searchBinary(arr,17));  //17
    

//   12.二分查找

    /**
     * 有序整型数组, 实现二分查找
     * @param arr
     * @param target 要找的数
     * @return
     */
    public static int searchBinary(int[] arr,int target)
        int left = 0;
        int right = arr.length-1;
        while(left <= right)
            int middle = (left+right)>>1;
            if (target == arr[middle])
                return arr[middle]; //返回要找的那个数值
            else if (target < arr[middle])
                right = middle-1;
            else
                left = middle+1;
            
        
        return -1;//未找到
    

 

13.数组的拷贝

实现一个方法 copyOf, 对一个整型数组进行拷贝, 得到一个新的数组.

import java.util.Arrays;

public class array 
    public static void main(String[] args) 
//    13.
        int[] arr = 3,7,2,4,8;
        int[] newarr = arryCopy(arr);//调用方法arryCopy
        System.out.println(Arrays.toString(newarr));//Arrays.toString将数组转换成String类型输出
    
//13.实现一个方法 copyOf, 对一个整型数组进行拷贝, 得到一个新的数组。
    public static int[] arryCopy(int[] arr) 
        int[] ret = new int[arr.length];//保持数组大小不变
        for (int i = 0; i < arr.length; i++) 
            ret[i] = arr[i];
        
        return ret;
    

 

14.数组转字符串

实现一个方法 toString, 把一个整型数组转换成字符串. 例如数组 1, 2, 3 , 返回的字符串为 "[1, 2, 3]", 注意 逗号 的位置和数量.

public class array 
    public static void main(String[] args) 
        int[] arr = 3,7,2,4,8;
        System.out.println(arrToStr(arr));
    
// 14.实现一个方法 toString, 把一个整型数组转换成字符串.
// 例如数组 1, 2, 3 , 返回的字符串为 "[1, 2, 3]", 注意逗号的位置和数量.
    public static String arrToStr(int[] arr)
        String ret = "[";
        for (int i = 0; i < arr.length; i++) 
            ret += arr[i];
            if (i<arr.length-1)
                ret += ",";
            
        
        ret += "]";
        return ret;
    

 

---

本小节完^_^