HJ101 输入整型数组和排序标识，对其元素按照升序或降序进行排序

HJ101 输入整型数组和排序标识，对其元素按照升序或降序进行排序

描述

输入整型数组和排序标识，对其元素按照升序或降序进行排序

数据范围： 1≤𝑛≤1000 1≤n≤1000 ，元素大小满足 0≤𝑣𝑎𝑙≤100000 0≤val≤100000

输入描述：

第一行输入数组元素个数
第二行输入待排序的数组，每个数用空格隔开
第三行输入一个整数0或1。0代表升序排序，1代表降序排序

输出描述：

输出排好序的数字

示例：

输入：
 8
 1 2 4 9 3 55 64 25
 0

输出：1 2 3 4 9 25 55 64

输入：
 5
 1 2 3 4 5
 1

输出：5 4 3 2 1

 
 

分析：

​ 1.使用Arrays.sort()方法。

​ 2.降序的话：逆序输出。

 
 

代码：

import java.util.*;
public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int length=sc.nextInt();
        int[] arr=new int[length];
        for (int i = 0; i < arr.length; i++) {
            arr[i]=sc.nextInt();
        }
        int type=sc.nextInt();


        Arrays.sort(arr);
        if(type==0){
            //升序
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i]+" ");
            }
        }else if(type==1){
            for (int i = arr.length - 1; i >= 0; i--) {
                System.out.print(arr[i]+" ");
            }
        }
    }
}

 
 

大佬代码：

使用外置比较器。

import java.util.*;
 
public class Main {
 
    public Main() {
    }
 
    public void sortIntegerArray(Integer[] pIntegerArray, int iSortFlag) {
        // 按升序
        if (iSortFlag == 0) {
            Arrays.sort(pIntegerArray, new Comparator<Integer>() {
                public int compare(Integer o1, Integer o2) {
                    return o1 - o2;
                }
            });
        }
        // 按降序
        else {
            Arrays.sort(pIntegerArray, new Comparator<Integer>() {
                public int compare(Integer o1, Integer o2) {
                    return o2 - o1;
                }
            });
        }
    }
 
    public void output(Integer[] array) {
        for (Integer i : array) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
 
    public static void main(String[] args) {
        Main solution = new Main();
        Scanner in = new Scanner(System.in);
        while (in.hasNextInt()) {
            int n = in.nextInt();
            Integer[] array = new Integer[n];
            for (int i = 0; i < n; i++) {
                array[i] = in.nextInt();
            }
            int flag = in.nextInt();
            solution.sortIntegerArray(array, flag);
            solution.output(array);
        }
 
    }
}

 

 
 

HJ102 字符统计

描述

输入一个只包含小写英文字母和数字的字符串，按照不同字符统计个数由多到少输出统计结果，如果统计的个数相同，则按照ASCII码由小到大排序输出。

数据范围：字符串长度满足 1≤𝑙𝑒𝑛(𝑠𝑡𝑟)≤1000 1≤len(str)≤1000

输入描述：

一个只包含小写英文字母和数字的字符串。

输出描述：

一个字符串，为不同字母出现次数的降序表示。若出现次数相同，则按ASCII码的升序输出。

示例:

输入：aaddccdc
输出：cda

说明：
	样例里，c和d出现3次，a出现2次，但c的ASCII码比d小，所以先输出c，再输出d，最后输出a.

 

分析：

​ 1.使用TreeMap集合存储数据。

​ 2.使用元素的内置比较器，max函数。

 

代码：

import java.util.*;
public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
       String s=sc.next();
       TreeMap<Character,Integer> map=new TreeMap<>();
        for (int i = 0; i < s.length(); i++) {
            if(map.containsKey(s.charAt(i))){
                map.replace(s.charAt(i),map.get(s.charAt(i))+1);
            }else {

                map.put(s.charAt(i),1);
            }
        }
        //System.out.println(map);


        //

        //获取map中所有的value
        Collection<Integer> values = map.values();
        //获取最大值 -- 利用元素的内置比较器
        int max = Collections.max(values);
        //System.out.println("max = " + max);
        while(max>0){

            Set<Character> keySet = map.keySet();
            for (Character key : keySet) {

                int value = map.get(key);
                //System.out.println("value = " + value);
                if(value==max){
                    System.out.print(key);
                }


            }
            max--;
        }
    }
}

 

 

大佬代码：

import java.util.Scanner;
import java.util.TreeMap;
 
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str = scanner.next();
 
        //将字符存入TreeMap
        TreeMap<Character,Integer> map = new TreeMap<>();
        for (int i = 0; i < str.length(); i++) {
            if(!map.containsKey(str.charAt(i))){
                map.put(str.charAt(i),1);
            }else{
                map.put(str.charAt(i),map.get(str.charAt(i))+1);
            }
        }
 
        //找到max值
        int max = 0;
        for (int val:map.values()) {
            if(val>max)
                max = val;
        }
 
        //输出
        while (max>0){
            for (char key:map.keySet()){
                if(map.get(key)==max)
                    System.out.print(key);
            }
            max--;
        }
 
    }
}

 
 

字符对应ascll码值下标元素自增来统计数量

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
public class Main {
 
    public static void main(String[] args) throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        String s;
        try{
            while((s=bf.readLine())!=null)
            {
                System.out.println(count(s).toString());
            }
        }catch(IOException e){
            e.printStackTrace();
        }
    }
    public static StringBuilder count(String str)
    {
        char[] chars = str.toCharArray();
        int[] chArray=new int[129];
        //字符对应ascll码值下标元素自增来统计数量
        for(char i:chars)
            chArray[(int)i]++;
        int max=0;
        //找出字符数量最多的ascll码值
        for(int i=0;i<chArray.length;i++)
            if(max<chArray[i])
                max=chArray[i];
        StringBuilder sb=new StringBuilder();
        //按数量从大到小添加到可变字符序列sb
        while(max!=0)
        {
            //遍历找到与当前max相等的字符
            for(int i=0;i<chArray.length;i++){
                if(chArray[i]==max)
                    sb.append((char)i);
            }
            //max减1 进入下一轮遍历
            max--;
        }
        return sb;
    }
}