Trier la matrice basée sur le nombre d'occurrences dans l'ordre croissant

package problems;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class SortByFrequency {

    public static void main(String args[]) {
        int arr[] = { 2, 5, 2, 6, -1, 9999999, 5, 8, 8, 8 };
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        int len = arr.length;
        for (int j = 0; j < len; j++) {
            if (map.get(arr[j]) == null) {
                map.put(arr[j], 1);
            } else {
                map.put(arr[j], (Integer) map.get(arr[j]) + 1);
            }
        }

        Set<Entry<Integer, Integer>> set = map.entrySet();
        ArrayList<Entry<Integer, Integer>> list = new ArrayList<Entry<Integer, Integer>>(set);
        list.sort(new Comparator<Entry<Integer, Integer>>() {
            @Override
            public int compare(Entry<Integer, Integer> o1, Entry<Integer, Integer> o2) {
                if (o1.getValue() < o2.getValue()) {
                    return 1;
                } else if (o1.getValue() > o2.getValue()) {
                    return -1;
                } else if (o1.getValue() == o2.getValue()) {
                    if (o1.getKey() < o2.getKey()) {
                        return 1;
                    } else {
                        return -1;
                    }
                }
                return 0;
            }
        });
        for (Map.Entry<Integer, Integer> en : list) {
            int val = en.getValue();
            while(val!=0){
            System.out.println(en.getKey());
            val--;          
            }
        }
    }

}

public class SortBasedOnFrequency {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String[] arr = new String[] { "abc", "def", "qas", "abc", "abc", "def" };

        new SortBasedOnFrequency().sort(arr);
    }

    void sort(String[] a) {
        Map<String, Integer> map = new HashMap<>();
        for (String s : a) {
//convert array to map putting key as the array element and value as the 
//number of occurence.
            map.put(s, map.get(s) == null ? 1 : map.get(s) + 1);
        }

    List<Map.Entry<String, Integer>> mapEntryList = new ArrayList<>map.entrySet());//  sort mapEntry list based on value
        Collections.sort(mapEntryList, new Comparator<Map.Entry<String, Integer>>() {

            @Override
            public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
                // TODO Auto-generated method stub
                return o1.getValue().compareTo(o2.getValue());
            }
        });
//print the object in sorting order of the occurrence.
        for (Entry<String, Integer> m : mapEntryList) {
            System.out.println(m.getKey() + " " + m.getValue());
        }
    }

}

Je n'ai pas aimé les réponses ci-dessus, alors j'ajoute ce que j'ai fait. L'idée générale est assez simple - trier simplement la liste par comparateur code> qui prendra comme argument la carte de hachage.

2 5 6 1 1 3 3 3 0 0 0 0 

import java.util.Arrays;
import java.util.Comparator;

public class TestString {
    public static void main(String[] args) {

        int arrTemp[] = { 2, 2, 2, 1, 1, 4, 5, 6, 6, 7, 7, 7, 7 };
        Arrays.sort(arrTemp);
        Integer[][] sortedArray = new Integer[6][2];
        int count = 0;
        sortedArray[count][0] = arrTemp[0];
        sortedArray[count][1] = 1;
        for (int i = 0; i < arrTemp.length - 1; i++) {
            for (int j = 1; j < arrTemp.length; j++) {
                if (arrTemp[i] == arrTemp[j]) {
                    sortedArray[count][1] = sortedArray[count][1] + 1;
                    i = j;
                } else {
                    ++count;
                    sortedArray[count][0] = arrTemp[j];
                    sortedArray[count][1] = 1;
                    i = j;
                }
            }
        }

        Arrays.sort(sortedArray, new Comparator<Integer[]>() {

            @Override
            public int compare(Integer[] o1, Integer[] o2) {
                return o1[1].compareTo(o2[1]);
            }
        });

        for (int row = 0; row < 6; row++) {
            for (int col = 0; col < sortedArray[row][1]; col++) {
                System.out.print(sortedArray[row][0] + " ");
            }
        }
    }
}

Utiliser simplement des tableaux. xxx

Utilisation de Treemap pour stocker l'élément en tant que clé, comptez les occurrences en tant que valeur, puis triez-la en fonction des valeurs. Java 8 flux rendez ci-dessous le code concis et simple à comprendre xxx

    public class Frequency {
        static int key;

        public static void main(String[] args) {
            Integer[] nums = { 7, 3, 4, 3, 4, 3, 4, 3, 6, 5, 7 };

            Map<Integer, Integer> m1;

//Convert the integer array into an Array List.
            ArrayList<Integer> numbers = new ArrayList<Integer>(Arrays.asList(nums));
    //ArrayList to store the number of occurences of numbers.
            List<Integer> values = new ArrayList<Integer>();
//ArrayList to show the array in requested order.
            List<Integer> output = new ArrayList<Integer>();

            m1 = new LinkedHashMap<Integer, Integer>();

            for (int a : numbers) {
    //Add data in Hash map where key is number and value is the total occurences of that number.
                if (m1.containsKey(a)) {
                    int value = m1.get(a);
                    m1.put(a, ++value);
                } else {
                    m1.put(a, 1);
                }
            }
            System.out.println(m1);
            for (Map.Entry<Integer, Integer> entry : m1.entrySet()) {
                values.add(entry.getValue());
            }

            Collections.sort(values, Collections.reverseOrder());
            System.out.println(values.toString());
            for (int m = 0; m < values.size(); m++) {
                for (Map.Entry<Integer, Integer> entry : m1.entrySet()) {
                    if (entry.getValue().equals(values.get(m))) {
                        key = entry.getKey();
                        System.out.println("Key is" + key);
                        for (int k = values.get(m); k > 0; k--) {
                            output.add(key);
                        }
                        break;
                    }

                }
                m1.remove(key);
            }
            System.out.println(output.toString());

        }
    }

traits de tri bas basé sur la fréquence:

public static void main(String[] args) {
    int arr[] = { 2, 5, 2, 6, -1, 9999999, 5, 8, 8, 8 };
    Map<Integer, Integer> mp = new LinkedHashMap<>();
    List<Integer> res = new ArrayList<>();
    int count = 1;
    for (int i = 0; i < arr.length; i++) {
        if (!mp.containsKey(arr[i])) {
            mp.put(arr[i], count);
        } else {
            mp.put(arr[i], mp.get(arr[i]) + 1);
        }
    }
    if (!mp.containsValue(2)) {
        for (Integer ab : arr)
            res.add(ab);
        Collections.sort(res);
        Collections.reverse(res);
        System.out.println(res);
    } else {
        Set<Entry<Integer, Integer>> set = mp.entrySet();
        List<Entry<Integer, Integer>> list = new ArrayList<>(set);
        Collections.sort(list, new Comparator<Entry<Integer, Integer>>() {
            @Override
            public int compare(Entry<Integer, Integer> obj1, Entry<Integer, Integer> obj2) {
                if (obj2.getValue() > obj1.getValue())
                    return 1;
                if (obj2.getValue() < obj1.getValue())
                    return -1;
                else
                    return 0;
            }
        });
        for (Map.Entry<Integer, Integer> e : list) {
            for (int i = 1; i <= e.getValue(); i++)
                res.add(e.getKey());
        }
        System.out.println(res);

    }
}

Je suis un débutant à coder, j'ai essayé cela en utilisant "pour la boucle". Voici mon code -

//Driver Program
public static void main(String args[])
{
    int[] array = { 2, 2, 3, 4, 5, 12, 2, 3, 3, 3, 12 };
    sortByCount(array);
}

//Array element's count
static int elementsCount(int ar[], int n)
{
    int count = 0;
    for(int i : ar)
    {
        int max = n;
        if(i == max)
        {
            count++;
        }
        max = i;
    }
    return count;
}

//Ascending order sort by count 
static void sortByCount(int ar[])
{
    int temp = 0;
    for(int i = 0; i < ar.length; i++)
    {
        for(int j = i + 1; j < ar.length; j++)
        {
            if(elementsCount(ar, ar[i]) > elementsCount(ar, ar[j]))
            {
                temp = ar[i];
                 ar[i] = ar[j];
                 ar[j] = temp;
            }
        }   
    }
    printArray(ar);
}

//Print Array
static void printArray(int[] ar)
{
    for(int i : ar)
    {
        System.out.println(i);
    }
}   

Utilisation de la carte, de l'arrayage et du comparateur

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

public class OrderArrayFrequency {

public static void main(String[] args) {
    int nums[] = {0,0,0,1,3,3,2,1,3,5,6,0};
    ConcurrentHashMap<Integer, Integer> counts = new ConcurrentHashMap<Integer, Integer>();
    for (int i = 0; i < nums.length; i++) {
        if (counts.containsKey(nums[i])) {
            Integer c = counts.get(nums[i]) + 1;
            counts.put(nums[i], c);
        } else {
            counts.put(nums[i], 1);
        }
    }

    ArrayList<Integer> list = new ArrayList<>();

    for (Integer i : counts.keySet()) {
        list.add(counts.get(i));
    }

    Collections.sort(list, new Comparator<Integer>() {

        @Override
        public int compare(Integer o1, Integer o2) {

            if (o1 < o2)
                return -1;
            return 0;
        }
    });


    Set<Entry<Integer, Integer>> set = counts.entrySet();
    for (Integer i : list) {
        for (Entry<Integer, Integer> entry : set) {
            if (entry.getValue().equals(i)) {
                System.out.print(entry.getKey()+":"+entry.getValue()+ " ");
                counts.remove(entry.getKey());
            }
        }
    }
}
}

import java.util.*;
class SortArrayByFrequency 
{

    public static void main(String[] args) 
    {
        int a[]={2,2,2,2,4,4,4,4,4,4,5,6,6,6,6,6,1,1,1};
        int count=0;
        int k[]=new int[10];// for elements
        int v[]=new int[10];//store the frquency of corresponding element


        Map<Integer,Integer> map=new HashMap<>();

        for(int i=0;i<a.length;i++)
        {

            if(map.containsKey(a[i]))
            {
                map.put(a[i],map.get(a[i])+1);
            }
            else
            {
                map.put(a[i],1);
            }
        }
        Set<Integer> keys=map.keySet();
        int i=0,j=0;
        for(int key:keys){
            //System.out.println(key+" : "+map.get(key));
            v[i++]=map.get(key);
            k[j++]=key;
        }
        System.out.println("--------------------");

        //Sort the array which contains the frquency of elements
        for(int f=0;f<i-1;f++){
            //System.out.println(k[f]+" "+v[f]);
            int min=f;
            for(int g=f+1;g<i;g++)
            {
                if(v[min]>v[g])
                {
                    min=g;
                }
            }
            int temp=v[min];
            v[min]=v[f];
            v[f]=temp;
            //here we swap the element according to sorting ------------
            int temp1=k[min];
            k[min]=k[f];
            k[f]=temp1;
        }
        System.out.println("-----Array sort by frequency in ascending order------------");
        for(int l=0;l<i;l++){
            //System.out.println(v[l]+"    :: "+k[l]);
            for(int p=0;p<v[l];p++)
            System.out.print(k[l]+" ");
        }

    }
}
Ascending order
//OUTPUT: 5 1 1 1 2 2 2 2 6 6 6 6 6 4 4 4 4 4 4

Utilisation Java 8

Trier les éléments de matrice en fonction de ses fréquences P>

Hypothèses - B>

1. Triez le tableau en fonction de son occurrence naturelle dans un ordre croissant de
2. Si deux chiffres ont les mêmes fréquences, triez-les en fonction de la précédente numéro naturelle P>

Exemple B>: - [1, 1, 1, 1, 1, 2, 2 , 2, 3, 3, 3, 4, 4, 5] code>
sortie b>: - [5, 4, 4, 2, 2, 2, 3, 3, 3, 1, 1, 1, 1, 1] code> p>

solution b>: -
1 B>. Créer un haschmap qui stocke les éléments de tableau et ses occurrences de
2 B>. Mettez HASHMAP dans une liste où nous pouvons appliquer le tri en fonction de ses fréquences à l'aide d'un comparateur personnalisé
3 b>. La comparaison d'objet est Java: -
Si obj1 code> est inférieur à (code> obj2 code> puis retourner -1 code>
Si obj1 code> est égal à obj2 code> puis retourner 0 code>
Si obj1 code> est supérieur, alors obj2 puis retourner +1 code>
4 B>. Dans notre cas, si deux chiffres ont les mêmes fréquences, nous devrions mettre le numéro qui a une priorité naturelle dans la sortie de la production Ex: - Si ci-dessus exemple, numéro 2 code> et 3 code> survenu 3 code> est donc 2 code> devrait venir d'abord p >

public static void sortTheArrayByFrequency(int[] array){
    Map<Integer, Integer> map = new HashMap<>();

    //put array elements based on its frequncies
    for(int i : array){
        map.put(i, map.getOrDefault(i,0)+1);  
    }

    //Put the hashmap into a list where we use customized comparator
    List<Map.Entry<Integer, Integer>> list = new ArrayList<>();
    for(Map.Entry<Integer, Integer> e : map.entrySet()){
        list.add(e);
    }

    // list looks like [1=5, 2=3, 3=3, 4=2, 5=1]

    Collections.sort(list, (a, b) -> {
        // if its ouccrances are same then sort natually
        //else sort based on freqncies
        if(a.getValue() == b.getValue())
            return a.getKey() - b.getKey();
        else
            return a.getValue() - b.getValue();
    });

    // list looks like [5=1, 4=2, 2=3, 3=3, 1=5]

    for(Map.Entry<Integer, Integer> e : list){
        int num = e.getValue();
        while(num!=0){
            System.out.print(e.getKey()+ " ");
            num--;
        }
    }
}

Déjà il a été répondu mais il n'y a pas de bonne explication du code.So je vais essayer cela ici. Laissez le tableau à trier être: int [] array = {4,4,2,2,2,2,3,3,1,1,6,7,5} code>

Tout d'abord, comptez la fréquence de chaque numéro: p>

Pour le faire, nous allons créer une structure de données HASHMAP qui aura les éléments de tableau en tant que clé et leur fréquence comme valeur.et pour stocker notre sortie que nous aura une liste de sortie. P>

hashmap freqmap = nouveau hashmap (); code> p>

= nouvelle arrayliste (); code> p>

getordefault (clé, défaitValue) code>: Ceci est un moyen pratique de gérer le scénario où nous voulons une valeur renvoyée autre que null qui est renvoyé par obtenir la méthode chaque fois que la clé n'a pas été trouvée. p>

venant au code: p> xxx pré>

Nous avons maintenant des éléments cartographiés avec leur Fréquence dans HASHMAP. P>

class SortComparator implements Comparator<Integer>
{
    private final Map<Integer,Integer> freqMap;
    SortComparator(Map<Integer,Integer>freqMap)
    {
        this.freqMap = freqMap;
    }
    public int compare(Integer k1,Integer k2)
    {
    //Comparing by frequency
        int freqCompare = freqMap.get(k2).compareTo(freqMap.get(k1));
    //Comparing by value
        int valueCompare = k2.compareTo(k1);

        if(freqCompare == 0)//frequency of both k1 and k2 is same then
        {
            return valueCompare;
        }
        else 
        {
            return freqCompare;
        }
    }

// tri de la matrice dans une ordonnance décroissante sur la base de leurs fréquences.

import java.util.*;

class sorting {

static int x = 0;

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();

    int a[] = new int[n];

    for(int i=0; i<n; i++){
        a[i] = sc.nextInt();
    }

    Arrays.sort(a);
    // l is number of distinct elements in array a.
    int l=1;
    for(int i=0; i<n-1; i++){
        if(a[i]!=a[i+1]){
            l++;
        }
    }

    // creating a 2d array from a 1d array having elements and their frequencies.
    int b[][] = new int[l][2];
    b[x][0] = a[0];
    int c=1;
    for(int i=1; i<n; i++){
        if(a[i]!=a[i-1]){
            b[x][1]=c;
            x++;
            c=1;
            b[x][0] = a[i];
        }
        else{
            c++;
        }

        if(i==n-1){
            b[x][1]=c;
        }
    }

    // sorting 2d array according their frequencies.
    for(int i=0; i<b.length; i++){
        for(int j=i; j<b.length; j++){
            if(b[i][1]<b[j][1]){
                int t = b[i][1];
                b[i][1] = b[j][1];
                b[j][1] = t;
                t = b[i][0];
                b[i][0] = b[j][0];
                b[j][0] = t;
            }
        }
    }

    for(int i=0; i<b.length; i++){
        int k=b[i][1];
        for(int j=0; j<k; j++){
            System.out.print(b[i][0]+" ");
        }
    }

}

// bubble sort.
public static void sort(int a[]) {
    int n = a.length;
    for(int i=0; i<n; i++){
        for(int j=i; j<n; j++){
            if(a[i]>a[j]){
                int t = a[i];
                a[i] = a[j];
                a[j] = t;
            }
        }
    }
}

}

Depuis Java 8, vous pouvez y parvenir avec une doublure one-liner (divisé en plusieurs lignes pour une meilleure lisibilité; -) xxx pré>

ou, si vous préférez un tableau de résultat p >

    int[] result = IntStream.of(numbers)
        .boxed()
        .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
        .entrySet()
        .stream()
        .sorted(Comparator.comparing(Map.Entry::getValue))
        .map(e -> Stream.generate(e::getKey).limit(e.getValue()))
        .flatMap(Function.identity())
        .mapToInt(Integer::intValue)
        .toArray();