Algorithm 基于频率的排序

给您一个整数数组，您可以根据
他们的出现。设计算法并分析其时间复杂度。如果系结，则较小的
编号应首先出现在已排序列表中

样本输入：3,4,3,2,3,5,4,2,2,1,2

---

样本输出：1 5 4 3 2

如果允许额外空间：检查输入并进行频率分析。把它写在一些散列表中。这大致意味着：

for each x in input:
  if x in table:
    ++table[x]
  else
    table.insert(x)

然后，对唯一值进行简单的快速排序，比较函数将考虑频率而不是值本身

即:

function freq_compare (x, y):
  return compare(table[x], table[y])

---

其中，

compare

是频率的数字。

如果允许额外的空间：检查输入并进行频率分析。把它写在一些散列表中。这大致意味着：

for each x in input:
  if x in table:
    ++table[x]
  else
    table.insert(x)

然后，对唯一值进行简单的快速排序，比较函数将考虑频率而不是值本身

即:

function freq_compare (x, y):
  return compare(table[x], table[y])

---

其中，

compare

是频率的数字。

对数组进行排序，然后我们可以很容易地获得数字的频率，因为重复的数字将被放置在彼此相邻的位置。当您获得数字的频率时，将其插入地图中，键为频率，值为数字。由于map按排序顺序存储键，因此我们可以迭代map以获得结果。

对数组进行排序，然后我们可以轻松获得数字的频率，因为重复的数字将彼此相邻放置。当您获得数字的频率时，将其插入地图中，键为频率，值为数字。由于map按排序顺序存储键，我们可以迭代map以获得结果。

首先制作HashMap，将数组元素作为键，将它们的频率作为值。 使用基于键和值的比较器对它们进行排序

import java.io.*;
import java.util.*;
import java.lang.*;
public class Sum_of
{
 public static HashMap<Integer, Integer> sortHashMapByValues(
    HashMap<Integer, Integer> passedMap) {
List<Integer> mapKeys = new ArrayList<>(passedMap.keySet());
List<Integer> mapValues = new ArrayList<>(passedMap.values());
Collections.sort(mapValues);
Collections.sort(mapKeys);

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

Iterator<Integer> valueIt = mapValues.iterator();
while (valueIt.hasNext()) {
    Integer val = valueIt.next();
    Iterator<Integer> keyIt = mapKeys.iterator();

    while (keyIt.hasNext()) {
        Integer key = keyIt.next();
        Integer comp1 = passedMap.get(key);
        Integer comp2 = val;

        if (comp1.equals(comp2)) {
            keyIt.remove();
            sortedMap.put(key, val);
            break;
        }
    }
}
return sortedMap;
}
   public static void main(String args[])
    {
      HashMap<Integer,Integer> hs = new HashMap<Integer,Integer>();
      int a[]={3,4,3,2,3,5,4,2,2,1,2};
       int n= a.length;
       int c=0;
       for(int i=0;i<n;i++)
        {
        if(hs.containsKey(a[i]))
        {
            c=hs.get(a[i]);
            hs.put(a[i],c+1);
        }
        else
        hs.put(a[i],1);
    }
     hs=Sum_of.sortHashMapByValues(hs);
    System.out.println(hs.keySet());
      }
 }

import java.io.*；
导入java.util.*；
导入java.lang.*；
公共类和
{
公共静态HashMap SorthashMapByValue(
HashMap passedMap）{
List mapKeys=new ArrayList（passedMap.keySet（））；
List mapValues=new ArrayList（passedMap.values（））；
Collections.sort（映射值）；
Collections.sort（映射键）；
LinkedHashMap分类地图=
新建LinkedHashMap（）；
迭代器值It=mapValues.Iterator（）；
while（valueIt.hasNext（））{
整数val=valueIt.next（）；
迭代器keyIt=mapKeys.Iterator（）；
while（keyIt.hasNext（））{
整数key=keyIt.next（）；
整数comp1=passedMap.get（key）；
整数comp2=val；
如果（comp1等于（comp2））{
keyIt.remove（）；
分类地图放置（键，val）；
打破
}
}
}
返回分拣的DMAP；
}
公共静态void main（字符串参数[]）
{
HashMap hs=新的HashMap（）；
int a[]={3,4,3,2,3,5,4,2,2,1,2}；
int n=a.长度；
int c=0；
对于（inti=0；i首先制作HashMap，将数组元素作为键，将它们的频率作为值。
使用基于键和值的比较器对它们进行排序

import java.io.*;
import java.util.*;
import java.lang.*;
public class Sum_of
{
 public static HashMap<Integer, Integer> sortHashMapByValues(
    HashMap<Integer, Integer> passedMap) {
List<Integer> mapKeys = new ArrayList<>(passedMap.keySet());
List<Integer> mapValues = new ArrayList<>(passedMap.values());
Collections.sort(mapValues);
Collections.sort(mapKeys);

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

Iterator<Integer> valueIt = mapValues.iterator();
while (valueIt.hasNext()) {
    Integer val = valueIt.next();
    Iterator<Integer> keyIt = mapKeys.iterator();

    while (keyIt.hasNext()) {
        Integer key = keyIt.next();
        Integer comp1 = passedMap.get(key);
        Integer comp2 = val;

        if (comp1.equals(comp2)) {
            keyIt.remove();
            sortedMap.put(key, val);
            break;
        }
    }
}
return sortedMap;
}
   public static void main(String args[])
    {
      HashMap<Integer,Integer> hs = new HashMap<Integer,Integer>();
      int a[]={3,4,3,2,3,5,4,2,2,1,2};
       int n= a.length;
       int c=0;
       for(int i=0;i<n;i++)
        {
        if(hs.containsKey(a[i]))
        {
            c=hs.get(a[i]);
            hs.put(a[i],c+1);
        }
        else
        hs.put(a[i],1);
    }
     hs=Sum_of.sortHashMapByValues(hs);
    System.out.println(hs.keySet());
      }
 }

import java.io.*；
导入java.util.*；
导入java.lang.*；
公共类和
{
公共静态HashMap SorthashMapByValue(
HashMap passedMap）{
List mapKeys=new ArrayList（passedMap.keySet（））；
List mapValues=new ArrayList（passedMap.values（））；
Collections.sort（映射值）；
Collections.sort（映射键）；
LinkedHashMap分类地图=
新建LinkedHashMap（）；
迭代器值It=mapValues.Iterator（）；
while（valueIt.hasNext（））{
整数val=valueIt.next（）；
迭代器keyIt=mapKeys.Iterator（）；
while（keyIt.hasNext（））{
整数key=keyIt.next（）；
整数comp1=passedMap.get（key）；
整数comp2=val；
如果（comp1等于（comp2））{
keyIt.remove（）；
分类地图放置（键，val）；
打破
}
}
}
返回分拣的DMAP；
}
公共静态void main（字符串参数[]）
{
HashMap hs=新的HashMap（）；
int a[]={3,4,3,2,3,5,4,2,2,1,2}；
int n=a.长度；
int c=0；
对于（int i=0；这听起来像是一个家庭作业问题……是吗？这绝对是一个家庭作业问题。它不是一个家庭作业问题。这个问题有很多实际应用，比如你可能想根据单词出现的次数对单词列表进行排序（比如根据它们的流行程度）这听起来像是一个家庭作业问题……是吗？这绝对是一个家庭作业问题。这不是一个家庭作业问题。这个问题有很多实际应用，比如你可能想根据单词出现的次数（比如根据它们的流行程度）对单词列表进行排序我曾经考虑过这一点，但在使用哈希表时，我们必须注意冲突。另外，您将如何仅对唯一值进行快速排序？在进行频率分析时，您需要将唯一值存储在某个位置。如果您手边有一个普通的哈希表实现，则冲突不会出现问题。如果该表不是太大小，整个插入的运行时间将为O（N）。至于唯一值-它们可以通过线性遍历哈希表中的所有键来获得。如果这真的不是家庭作业，请下载GLib。它有一个很好的哈希表实现，您可以使用。我曾想过这一点，但在使用哈希表时，我们必须注意冲突。此外，您将如何仅在uniq上进行快速排序ue值？在进行频率分析时，您需要将唯一值存储在某个位置。如果您手头有一个正常的哈希表实现，则不会出现冲突问题。如果该表不是太小，则整个插入的运行时间将为O（N）。至于唯一值-它们可以通过线性遍历哈希表中的所有键来获得。如果这真的不是家庭作业，请下载GLib。它有一个很好的哈希表实现。如果多个数字具有相同的频率，您可以使用此方法失败，因为相同频率的旧数字将在对于同一个键（频率），将有多个值（数字）。@Abhinavkumar true it wi