在Java中对元素进行就地排序

我试图通过降低频率对给定元素的列表进行排序。如果两个元素具有相同的频率，则它们应按递增顺序出现。例如，给定输入：

[6,1000,3,3,1000,6,6,6]

输出应该是：

[6,6,6,3,3,1000,1000]

。元素也必须就地排序，而不是返回新列表

到目前为止，我已经创建了键和值的HashMap，其中键是元素，值是频率。但我不太确定下一步该怎么办：

public static void method(List<Integer> items)
{
        int size = items.size();
        int count = 0;
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < size; ++i)
        {
            int item = items.get(i);
            if (map.containsKey(item))
            {
                map.put(item, map.get(item) + 1);
            }
            else
            {
                map.put(item, 1);
            }
        }
        List list = new LinkedList(map.entrySet());
        Collections.sort(list, new Comparator()
        {
            public int compare(Object o1, Object o2)
            {
                return ((Comparable) ((Map.Entry) (o1)).getValue())
                .compareTo(((Map.Entry) (o2)).getValue());
            }
        });
        HashMap sortedMap = new LinkedHashMap();
        for (Iterator it = list.iterator(); it.hasNext();)
        {
            Map.Entry entry = (Map.Entry) it.next();
            sortedMap.put(entry.getKey(), entry.getValue());
        }
}

公共静态作废方法（列表项）
{
int size=items.size（）；
整数计数=0；
HashMap=newHashMap（）；
对于（int i=0；i

公共静态无效方法（列表）{
Map=list.stream（）
.collect（收集器.groupingBy（Function.identity（）），
收集器。计数（）；
list.sort（新的比较器（）{
@凌驾
公共整数比较（整数o1，整数o2）{
长cnt1=map.get（o1）；
长cnt2=map.get（o2）；
int compare=cnt2.compareTo（cnt1）；
如果（比较==0）{
返回o1。与（o2）相比；
}
返回比较；
}
});
}

您可以按如下方式进行内联排序：

public static void sortInline(List<Integer> list) {
    Map<Integer, Long> map = list.stream()
            .collect(Collectors.groupingBy(Function.identity(),
                    Collectors.counting())); // frequency map
    Comparator<Integer> frequencyComparison = Comparator
            .<Integer>comparingLong(map::get).reversed(); // sort the entries by value in reverse order 
    list.sort(frequencyComparison.thenComparing(Comparator.naturalOrder())); // then by key for the collisions
}

publicstaticvoidsortinline（列表）{
Map=list.stream（）
.collect（收集器.groupingBy（Function.identity（）），
Collectors.counting（））；//频率映射
比较器频率比较器=比较器
.comparingLong（map:：get）.reversed（）；//按值按相反顺序对条目排序
list.sort（frequencycomparation.thencomparation（Comparator.naturalOrder（））；//然后按键进行冲突
}

如果两个不同频率出现相同次数，顺序是什么？不要使用原始类型。你一开始就很得体，在中间迷失了方向。考虑一下这个问题——“你需要按照值的相反顺序对条目进行排序，然后按照键对冲突进行排序。”@WJS我认为问题陈述清楚地总结在“我试图通过降低频率对给定元素的列表进行排序。如果两个元素具有相同的频率，它们应该以增加的顺序出现。”然后，示例输出

[6,6,6,6,3,3,1000,1000]

进一步澄清了这一点。我在

map.get（o1）

和

map.get（o2）

-“long无法转换为整数”这一行上遇到了一个错误，对此我深表歉意。我更新了地图创建以避免手动操作，并且忘记了更新比较器。

public static void sortInline(List<Integer> list) {
    Map<Integer, Long> map = list.stream()
            .collect(Collectors.groupingBy(Function.identity(),
                    Collectors.counting())); // frequency map
    Comparator<Integer> frequencyComparison = Comparator
            .<Integer>comparingLong(map::get).reversed(); // sort the entries by value in reverse order 
    list.sort(frequencyComparison.thenComparing(Comparator.naturalOrder())); // then by key for the collisions
}