Java 根据相似元素的出现次数对arraylist进行排序

我有一个ArrayList，它包含

{2,2,1,1,1,5,4,4,4,4}

，我想根据每个元素的出现次数对它进行排序。因此它将给出

{4,4,4,4,4,1,1,1,2,2,5}

。我从哪里开始

import java.util.*;

public class SortingL{

  public static void main(String[] args){

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

    Integer[] al = new Integer[] {2,2,1,1,1,5,4,4,4,4,4};
    list.addAll(Arrays.asList(al));

    sortL(list);

  }

  public static ArrayList<Integer> sortL(ArrayList<Integer> list){


    return list;
  }
}

import java.util.*；
公共分类{
公共静态void main（字符串[]args）{
ArrayList=新建ArrayList（）；
整数[]al=新整数[]{2,2,1,1,1,5,4,4,4}；
addAll（Arrays.asList（al））；
sortL（名单）；
}
公共静态ArrayList sortL（ArrayList列表）{
退货清单；
}
}
一种解决方案是使用
集合#频率
：

List<Integer> list = Arrays.asList(2, 2, 1, 1, 1, 5, 4, 4, 4, 4, 4);

list.sort(Comparator.comparing(i -> Collections.frequency(list, i)).reversed());

System.out.println(list);

List List=Arrays.asList（2,2,1,1,1,5,4,4,4）；
list.sort（Comparator.comparing（i->Collections.frequency（list，i））.reversed（））；
系统输出打印项次（列表）；

这将输出预期结果：

[4,4,4,4,4,1,1,1,2,2,5]

一种解决方案是使用
集合#频率
：

List<Integer> list = Arrays.asList(2, 2, 1, 1, 1, 5, 4, 4, 4, 4, 4);

list.sort(Comparator.comparing(i -> Collections.frequency(list, i)).reversed());

System.out.println(list);

List List=Arrays.asList（2,2,1,1,1,5,4,4,4）；
list.sort（Comparator.comparing（i->Collections.frequency（list，i））.reversed（））；
系统输出打印项次（列表）；

这将输出预期结果：

[4,4,4,4,4,1,1,1,2,2,5]

您可以使用O（N）（几乎不需要内存空间的折衷）。
)

列表项
创建哈希映射
迭代输入元素并保持每个元素的计数
hashmap中的元素
现在按频率迭代地图的键和桶号
现在以相反的顺序迭代bucket
代码：

public List frequencyBasedSort（int[]nums，int k）{
List[]bucket=新列表[nums.length+1]；
Map freqMap=newhashmap（）；
用于（整数n:nums）{
freqMap.put（n，freqMap.getOrDefault（n，0）+1）；
}
for（int键：freqMap.keySet（））{
int frequency=freqMap.get（键）；
如果（桶[频率]==null）{
bucket[frequency]=new ArrayList（）；
}
bucket[频率]。添加（键）；
}
List res=new ArrayList（）；
对于（int i=bucket.length-1；i>=0；i--）{
if（bucket[i]！=null）{
res.addAll（桶[i]）；
}
}
返回res；
}
您可以使用O（N）（几乎不需要内存空间的折衷）。
)

列表项
创建哈希映射
迭代输入元素并保持每个元素的计数
hashmap中的元素
现在按频率迭代地图的键和桶号
现在以相反的顺序迭代bucket
代码：

public List frequencyBasedSort（int[]nums，int k）{
List[]bucket=新列表[nums.length+1]；
Map freqMap=newhashmap（）；
用于（整数n:nums）{
freqMap.put（n，freqMap.getOrDefault（n，0）+1）；
}
for（int键：freqMap.keySet（））{
int frequency=freqMap.get（键）；
如果（桶[频率]==null）{
bucket[frequency]=new ArrayList（）；
}
bucket[频率]。添加（键）；
}
List res=new ArrayList（）；
对于（int i=bucket.length-1；i>=0；i--）{
if（bucket[i]！=null）{
res.addAll（桶[i]）；
}
}
返回res；
}
为了获得最佳性能，首先构建一个值的
映射图来计算值。然后按计数对其排序，然后重新构建数组

其效果是，相同次数出现的不同值将合并。您可能希望指定二级顺序，然后对它们进行一致排序

例如：

public static void main(String[] args) {
    ArrayList<Integer> input = new ArrayList<>(Arrays.asList(2,2,1,1,1,5,4,4,4,4,4));
    ArrayList<Integer> sorted = sortL(input);
    System.out.println(sorted); // prints: [4, 4, 4, 4, 4, 1, 1, 1, 2, 2, 5]
}
public static <V extends Comparable<V>> ArrayList<V> sortL(List<V> input) {
    Map<V, ValueCount<V>> map = new HashMap<>();
    for (V value : input)
        map.computeIfAbsent(value, ValueCount<V>::new).count++;
    @SuppressWarnings("unchecked")
    ValueCount<V>[] arr = map.values().toArray(new ValueCount[map.size()]);
    Arrays.sort(arr);
    ArrayList<V> sorted = new ArrayList<>(input.size());
    for (ValueCount<V> vc : arr)
        for (int i = 0; i < vc.count; i++)
            sorted.add(vc.value);
    return sorted;
}
private static final class ValueCount<V extends Comparable<V>> implements Comparable<ValueCount<V>> {
    final V value;
    int count;
    ValueCount(V value) {
        this.value = value;
    }
    @Override
    public int compareTo(ValueCount<V> that) {
        int cmp = Integer.compare(that.count, this.count); // descending
        if (cmp == 0)
            cmp = that.value.compareTo(this.value); // descending
        return cmp;
    }
}

publicstaticvoidmain（字符串[]args）{
ArrayList输入=新的ArrayList（Arrays.asList（2,2,1,1,5,4,4,4,4））；
ArrayList sorted=sortL（输入）；
System.out.println（排序）；//prints:[4,4,4,1,1,2,2,5]
}
公共静态ArrayList sortL（列表输入）{
Map Map=newhashmap（）；
用于（V值：输入）
computeIfAbsent（value，ValueCount:：new）.count++；
@抑制警告（“未选中”）
ValueCount[]arr=map.values（）.toArray（新的ValueCount[map.size（）]）；
数组。排序（arr）；
ArrayList sorted=新的ArrayList（input.size（））；
对于（ValueCount vc:arr）
对于（int i=0；i
为了获得最佳性能，首先构建一个值的
映射图来计算值。然后按计数对其排序，然后重新构建数组

其效果是，相同次数出现的不同值将合并。您可能希望指定二级顺序，然后对它们进行一致排序

例如：

public static void main(String[] args) {
    ArrayList<Integer> input = new ArrayList<>(Arrays.asList(2,2,1,1,1,5,4,4,4,4,4));
    ArrayList<Integer> sorted = sortL(input);
    System.out.println(sorted); // prints: [4, 4, 4, 4, 4, 1, 1, 1, 2, 2, 5]
}
public static <V extends Comparable<V>> ArrayList<V> sortL(List<V> input) {
    Map<V, ValueCount<V>> map = new HashMap<>();
    for (V value : input)
        map.computeIfAbsent(value, ValueCount<V>::new).count++;
    @SuppressWarnings("unchecked")
    ValueCount<V>[] arr = map.values().toArray(new ValueCount[map.size()]);
    Arrays.sort(arr);
    ArrayList<V> sorted = new ArrayList<>(input.size());
    for (ValueCount<V> vc : arr)
        for (int i = 0; i < vc.count; i++)
            sorted.add(vc.value);
    return sorted;
}
private static final class ValueCount<V extends Comparable<V>> implements Comparable<ValueCount<V>> {
    final V value;
    int count;
    ValueCount(V value) {
        this.value = value;
    }
    @Override
    public int compareTo(ValueCount<V> that) {
        int cmp = Integer.compare(that.count, this.count); // descending
        if (cmp == 0)
            cmp = that.value.compareTo(this.value); // descending
        return cmp;
    }
}

publicstaticvoidmain（字符串[]args）{
ArrayList输入=新的ArrayList（Arrays.asList（2,2,1,1,5,4,4,4,4））；
ArrayList sorted=sortL（输入）；
System.out.println（排序）；//prints:[4,4,4,1,1,2,2,5]
}
公共静态ArrayList sortL（列表输入）{
Map Map=newhashmap（）；
用于（V值：输入）
computeIfAbsent（value，ValueCount:：new）.count++；
@抑制警告（“未选中”）
ValueCount[]arr=map.values（）.toArray（新的ValueCount[map.size（）]）；
数组。排序（arr）；
ArrayList sorted=新的ArrayList（input.size（））；
对于（ValueCount vc:arr）
对于（int i=0；i