在O（1）额外空间和O（n）时间内计算阵列中所有元素的频率-yiteyi-C++库

给定一个由n个整数组成的未排序数组，该数组可以包含从1到n的整数。一些元素可以重复多次，而另一些元素可能不在数组中。计算存在的所有元素的频率，并打印缺失的元素。

null

例如：

Input: arr[] = {2, 3, 3, 2, 5}Output: Below are frequencies of all elements        1 -> 0        2 -> 2        3 -> 2        4 -> 0        5 -> 1Explanation: Frequency of elements 1 is 0, 2 is 2, 3 is 2, 4 is 0 and 5 is 1. Input: arr[] = {4, 4, 4, 4}Output: Below are frequencies of all elements        1 -> 0        2 -> 0        3 -> 0        4 -> 4Explanation: Frequency of elements 1 is 0, 2 is 0, 3 is 0 and 4 is 4.

建议：请在“上解决” 实践 “首先，在讨论解决方案之前。

简单解决方案

方法： 创建一个大小为n的额外空间，因为数组的元素在1到n的范围内。将额外空间用作哈希图。遍历数组并更新当前元素的计数。最后，打印HashMap的频率和索引。
算法：
1. 创建一个大小为n的额外空间( 陛下 )，将其用作哈希映射。
2. 从头到尾遍历阵列。
3. 对于每个元素更新 hm[array[i]-1] ，即。 hm[array[i]-1]++
4. 运行从0到n的循环并打印 hm[array[i]-1] 连同索引我
实施：

C++

                         // C++ program to print frequencies of all array                       
                         // elements in O(n) extra space and O(n) time                       
                         #include<bits/stdc++.h>                       
                         using                                     namespace                                     std;                       
           
                         // Function to find counts of all elements present in                       
                         // arr[0..n-1]. The array elements must be range from                       
                         // 1 to n                       
                         void                                     findCounts(                                     int                                     *arr,                                     int                                     n)                       
                         {                       
                                                 //Hashmap                       
                                                 int                                     hash[n]={0};                       
           
                                                 // Traverse all array elements                       
                                                 int                                     i = 0;                       
                                                 while                                     (i<n)                       
                                                 {                       
                                                 //update the frequency of array[i]                       
                                                 hash[arr[i]-1]++;                       
                                   
                                                 //increase the index                       
                                                 i++;                       
                                                 }                       
           
                                                 printf                                     (                                     "Below are counts of all elements"                                     );                       
                                                 for                                     (                                     int                                     i=0; i<n; i++)                       
                                                 printf                                     (                                     "%d -> %d"                                     , i+1, hash[i]);                       
                         }                       
           
                         // Driver program to test above function                       
                         int                                     main()                       
                         {                       
                                                 int                                     arr[] = {2, 3, 3, 2, 5};                       
                                                 findCounts(arr,                                     sizeof                                     (arr)/                                     sizeof                                     (arr[0]));                       
           
                                                 int                                     arr1[] = {1};                       
                                                 findCounts(arr1,                                     sizeof                                     (arr1)/                                     sizeof                                     (arr1[0]));                       
           
                                                 int                                     arr3[] = {4, 4, 4, 4};                       
                                                 findCounts(arr3,                                     sizeof                                     (arr3)/                                     sizeof                                     (arr3[0]));                       
           
                                                 int                                     arr2[] = {1, 3, 5, 7, 9, 1, 3, 5, 7, 9, 1};                       
                                                 findCounts(arr2,                                     sizeof                                     (arr2)/                                     sizeof                                     (arr2[0]));                       
           
                                                 int                                     arr4[] = {3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3};                       
                                                 findCounts(arr4,                                     sizeof                                     (arr4)/                                     sizeof                                     (arr4[0]));                       
           
                                                 int                                     arr5[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};                       
                                                 findCounts(arr5,                                     sizeof                                     (arr5)/                                     sizeof                                     (arr5[0]));                       
           
                                                 int                                     arr6[] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};                       
                                                 findCounts(arr6,                                     sizeof                                     (arr6)/                                     sizeof                                     (arr6[0]));                       
           
                                                 return                                     0;                       
                         }                       

JAVA

                         // Java program to print frequencies of all array                       
                         // elements in O(n) extra space and O(n) time                       
                         import                                     java.util.*;                       
           
                         class                                     GFG{                       
                                   
                         // Function to find counts of all elements                       
                         // present in arr[0..n-1]. The array elements                       
                         // must be range from 1 to n                       
                         public                                     static                                     void                                     findCounts(                                     int                                     arr[],                                     int                                     n)                       
                         {                       
                                   
                                                 // Hashmap                       
                                                 int                                     hash[] =                                     new                                     int                                     [n];                       
                                                 Arrays.fill(hash,                                     0                                     );                       
                                   
                                                 // Traverse all array elements                       
                                                 int                                     i =                                     0                                     ;                       
                                   
                                                 while                                     (i < n)                       
                                                 {                       
                                   
                                                 // Update the frequency of array[i]                       
                                                 hash[arr[i] -                                     1                                     ]++;                       
                                   
                                                 // Increase the index                       
                                                 i++;                       
                                                 }                       
                                                 System.out.println(                                     "Below are counts "                                     +                       
                                                 "of all elements"                                     );                       
                                                 for                                     (i =                                     0                                     ; i < n; i++)                       
                                                 {                       
                                                 System.out.println((i +                                     1                                     ) +                                     " -> "                                     +                       
                                                 hash[i]);                       
                                                 }                       
                         }                       
           
                         // Driver code                       
                         public                                     static                                     void                                     main(String []args)                       
                         {                       
                                                 int                                     arr[] = {                                     2                                     ,                                     3                                     ,                                     3                                     ,                                     2                                     ,                                     5                                     };                       
                                                 findCounts(arr, arr.length);                       
                                   
                                                 int                                     arr1[] = {                                     1                                     };                       
                                                 findCounts(arr1, arr1.length);                       
                                   
                                                 int                                     arr3[] = {                                     4                                     ,                                     4                                     ,                                     4                                     ,                                     4                                     };                       
                                                 findCounts(arr3, arr3.length);                       
                                   
                                                 int                                     arr2[] = {                                     1                                     ,                                     3                                     ,                                     5                                     ,                                     7                                     ,                                     9                                     ,                       
                                                 1                                     ,                                     3                                     ,                                     5                                     ,                                     7                                     ,                                     9                                     ,                                     1                                     };                       
                                                 findCounts(arr2, arr2.length);                       
                                   
                                                 int                                     arr4[] = {                                     3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ,                       
                                                 3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     };                       
                                                 findCounts(arr4, arr4.length);                       
                                   
                                                 int                                     arr5[] = {                                     1                                     ,                                     2                                     ,                                     3                                     ,                                     4                                     ,                                     5                                     ,                                     6                                     ,                       
                                                 7                                     ,                                     8                                     ,                                     9                                     ,                                     10                                     ,                                     11                                     };                       
                                                 findCounts(arr5, arr5.length);                       
                                   
                                                 int                                     arr6[] = {                                     11                                     ,                                     10                                     ,                                     9                                     ,                                     8                                     ,                                     7                                     ,                       
                                                 6                                     ,                                     5                                     ,                                     4                                     ,                                     3                                     ,                                     2                                     ,                                     1                                     };                       
                                                 findCounts(arr6, arr6.length);                       
                         }                       
                         }                       
           
                         // This code is contributed by rag2127                       

Python3

                         # Python3 program to print frequencies                       
                         # of all array elements in O(n) extra                       
                         # space and O(n) time                       
           
                         # Function to find counts of all                       
                         # elements present in arr[0..n-1].                       
                         # The array elements must be range                       
                         # from 1 to n                       
                         def                                     findCounts(arr, n):                       
           
                                                 # Hashmap                       
                                                 hash                                     =                                     [                                     0                                     for                                     i                                     in                                     range                                     (n)]                       
           
                                                 # Traverse all array elements                       
                                                 i                                     =                                     0                       
           
                                                 while                                     (i < n):                       
                                   
                                                 # Update the frequency of array[i]                       
                                                 hash                                     [arr[i]                                     -                                     1                                     ]                                     +                                     =                                     1                       
           
                                                 # Increase the index                       
                                                 i                                     +                                     =                                     1                       
                                   
                                                 print                                     (                                     "Below are counts of all elements"                                     )                       
                                                 for                                     i                                     in                                     range                                     (n):                       
                                                 print                                     (i                                     +                                     1                                     ,                                     "->"                                     ,                                     hash                                     [i], end                                     =                                     " "                                     )                       
                                                 print                                     ()                       
           
                         # Driver code                       
                         arr                                     =                                     [                                     2                                     ,                                     3                                     ,                                     3                                     ,                                     2                                     ,                                     5                                     ]                       
                         findCounts(arr,                                     len                                     (arr))                       
           
                         arr1                                     =                                     [                                     1                                     ]                       
                         findCounts(arr1,                                     len                                     (arr1))                       
           
                         arr3                                     =                                     [                                     4                                     ,                                     4                                     ,                                     4                                     ,                                     4                                     ]                       
                         findCounts(arr3,                                     len                                     (arr3))                       
           
                         arr2                                     =                                     [                                     1                                     ,                                     3                                     ,                                     5                                     ,                                     7                                     ,                                     9                                     ,                       
                                                 1                                     ,                                     3                                     ,                                     5                                     ,                                     7                                     ,                                     9                                     ,                                     1                                     ]                       
                         findCounts(arr2,                                     len                                     (arr2))                       
           
                         arr4                                     =                                     [                                     3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ,                       
                                                 3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ]                       
                         findCounts(arr4,                                     len                                     (arr4))                       
           
                         arr5                                     =                                     [                                     1                                     ,                                     2                                     ,                                     3                                     ,                                     4                                     ,                                     5                                     ,                       
                                                 6                                     ,                                     7                                     ,                                     8                                     ,                                     9                                     ,                                     10                                     ,                                     11                                     ]                       
                         findCounts(arr5,                                     len                                     (arr5))                       
           
                         arr6                                     =                                     [                                     11                                     ,                                     10                                     ,                                     9                                     ,                                     8                                     ,                                     7                                     ,                       
                                                 6                                     ,                                     5                                     ,                                     4                                     ,                                     3                                     ,                                     2                                     ,                                     1                                     ]                       
                         findCounts(arr6,                                     len                                     (arr6))                       
           
                         # This code is contributed by avanitrachhadiya2155                       

C#

                         // C# program to print frequencies of all array                       
                         // elements in O(n) extra space and O(n) time                       
                         using                                     System;                       
           
                         class                                     GFG                       
                         {                       
           
                                                 // Function to find counts of all elements                       
                                                 // present in arr[0..n-1]. The array elements                       
                                                 // must be range from 1 to n                       
                                                 public                                     static                                     void                                     findCounts(                                     int                                     [] arr,                                     int                                     n)                       
                                                 {                       
           
                                                 // Hashmap                       
                                                 int                                     [] hash =                                     new                                     int                                     [n];                       
           
                                                 // Traverse all array elements                       
                                                 int                                     i = 0;                       
                                                 while                                     (i < n)                       
                                                 {                       
           
                                                 // Update the frequency of array[i]                       
                                                 hash[arr[i] - 1]++;                       
           
                                                 // Increase the index                       
                                                 i++;                       
                                                 }                       
                                                 Console.WriteLine(                                     "Below are counts "                       
                                                 +                                     "of all elements"                                     );                       
                                                 for                                     (i = 0; i < n; i++)                       
                                                 {                       
                                                 Console.WriteLine((i + 1) +                                     " -> "                                     + hash[i]);                       
                                                 }                       
                                                 }                       
           
                                                 // Driver code                       
                                                 static                                     public                                     void                                     Main()                       
                                                 {                       
                                                 int                                     [] arr =                                     new                                     int                                     [] { 2, 3, 3, 2, 5 };                       
                                                 findCounts(arr, arr.Length);                       
                                                 int                                     [] arr1 =                                     new                                     int                                     [] { 1 };                       
                                                 findCounts(arr1, arr1.Length);                       
                                                 int                                     [] arr3 =                                     new                                     int                                     [] { 4, 4, 4, 4 };                       
                                                 findCounts(arr3, arr3.Length);                       
                                                 int                                     [] arr2                       
                                                 =                                     new                                     int                                     [] { 1, 3, 5, 7, 9, 1, 3, 5, 7, 9, 1 };                       
                                                 findCounts(arr2, arr2.Length);                       
                                                 int                                     [] arr4                       
                                                 =                                     new                                     int                                     [] { 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };                       
                                                 findCounts(arr4, arr4.Length);                       
                                                 int                                     [] arr5 =                                     new                                     int                                     [] { 1, 2, 3, 4,  5, 6,                       
                                                 7, 8, 9, 10, 11 };                       
                                                 findCounts(arr5, arr5.Length);                       
                                                 int                                     [] arr6 =                                     new                                     int                                     [] { 11, 10, 9, 8, 7, 6,                       
                                                 5,  4,  3, 2, 1 };                       
                                                 findCounts(arr6, arr6.Length);                       
                                                 }                       
                         }                       
           
                         // This code is contributed by Dharanendra L V                       

Javascript

                         <script>                       
                         // Javascript program to print frequencies of all array                       
                         // elements in O(n) extra space and O(n) time                       
           
                         // Function to find counts of all elements                       
                         // present in arr[0..n-1]. The array elements                       
                         // must be range from 1 to n                       
                         function                                     findCounts(arr,n)                       
                         {                       
                                                 // Hashmap                       
                                                 let hash =                                     new                                     Array(n);                       
                                                 for                                     (let i=0;i<n;i++)                       
                                                 {                       
                                                 hash[i]=0;                       
                                                 }                       
                                   
                                   
                                                 // Traverse all array elements                       
                                                 let i = 0;                       
                                   
                                                 while                                     (i < n)                       
                                                 {                       
                                   
                                                 // Update the frequency of array[i]                       
                                                 hash[arr[i] - 1]++;                       
                                   
                                                 // Increase the index                       
                                                 i++;                       
                                                 }                       
                                                 document.write(                                     "<br>Below are counts "                                     +                       
                                                 "of all elements<br>"                                     );                       
                                                 for                                     (i = 0; i < n; i++)                       
                                                 {                       
                                                 document.write((i + 1) +                                     " -> "                                     +                       
                                                 hash[i]+                                     "<br>"                                     );                       
                                                 }                       
                         }                       
           
                         // Driver code                       
                         let arr = [ 2, 3, 3, 2, 5 ];                       
                         findCounts(arr, arr.length);                       
           
                         let arr1 = [1];                       
                         findCounts(arr1, arr1.length);                       
           
                         let arr3 = [ 4, 4, 4, 4 ];                       
                         findCounts(arr3, arr3.length);                       
           
                         let arr2 = [ 1, 3, 5, 7, 9,                       
                                                 1, 3, 5, 7, 9, 1 ];                       
                         findCounts(arr2, arr2.length);                       
           
                         let arr4 = [ 3, 3, 3, 3, 3,                       
                                                 3, 3, 3, 3, 3, 3 ];                       
                         findCounts(arr4, arr4.length);                       
           
                         let arr5 = [ 1, 2, 3, 4, 5, 6,                       
                                                 7, 8, 9, 10, 11 ];                       
                         findCounts(arr5, arr5.length);                       
           
                         let arr6 = [ 11, 10, 9, 8, 7,                       
                                                 6, 5, 4, 3, 2, 1 ];                       
                         findCounts(arr6, arr6.length);                       
           
           
           
                         // This code is contributed by ab2127                       
                         </script>                       

输出：

Below are counts of all elements1 -> 02 -> 23 -> 24 -> 05 -> 1Below are counts of all elements1 -> 1Below are counts of all elements1 -> 02 -> 03 -> 04 -> 4Below are counts of all elements1 -> 32 -> 03 -> 24 -> 05 -> 26 -> 07 -> 28 -> 09 -> 210 -> 011 -> 0Below are counts of all elements1 -> 02 -> 03 -> 114 -> 05 -> 06 -> 07 -> 08 -> 09 -> 010 -> 011 -> 0Below are counts of all elements1 -> 12 -> 13 -> 14 -> 15 -> 16 -> 17 -> 18 -> 19 -> 110 -> 111 -> 1Below are counts of all elements1 -> 12 -> 13 -> 14 -> 15 -> 16 -> 17 -> 18 -> 19 -> 110 -> 111 -> 1

复杂性分析：
- 时间复杂性： O（n）。因为数组的单个遍历需要O（n）个时间。
- 空间复杂性： O（n）。要在HashMap中存储所有元素，需要O（n）空间。

下面是在O（n）时间和O（1）额外空间内解决此问题的两种有效方法。这两种方法都会修改给定的数组以获得O（1）额外空间。

方法2 : 通过使元素为负。

方法： 其思想是遍历给定的数组，使用元素作为索引，并将它们的计数存储在索引中。考虑基本方法，需要一个大小n的哈希图，数组也是大小n。因此数组可以用作一个哈希映射，数组的所有元素都是从1到n，即所有都是正元素。因此，频率可以存储为负值。这可能会导致一个问题。允许 第i次 元素，则计数应存储在 数组[a-1] ，但当存储频率时，元素将丢失。为了解决这个问题，首先用数组[a-1]替换第i个元素，然后将-1放在数组[a-1]上。所以我们的想法是用频率替换元素，并将元素存储在当前索引中，如果数组[a-1]中的元素已经是负数，那么它已经被一个频率替换，所以减量 数组[a-1] .

图片[1]-在O（1）额外空间和O（n）时间内计算阵列中所有元素的频率-yiteyi-C++库

算法：
1. 从头到尾遍历阵列。
2. 对于每个元素，检查元素是否小于或等于零。如果为负或为零，则跳过该元素，因为它是频率。
3. 如果一个元素( e=阵列[i]–1 )是阳性，然后检查 数组[e] 是积极的还是消极的。如果为正，则表示这是数组中第一次出现e并替换 数组[i] 具有 数组[e] ，即 数组[i]=数组[e] 分配 数组[e]=-1 如果 数组[e] 如果是阴性，那么它不是第一次出现，更新 数组[e] 像 数组[e]– 更新 数组[i] 像 数组[i]=0 .
4. 再次遍历数组，将i+1打印为值，将数组[i]打印为频率。
实施：

C++

                         // C++ program to print frequencies of all array                       
                         // elements in O(1) extra space and O(n) time                       
                         #include<bits/stdc++.h>                       
                         using                                     namespace                                     std;                       
           
                         // Function to find counts of all elements present in                       
                         // arr[0..n-1]. The array elements must be range from                       
                         // 1 to n                       
                         void                                     findCounts(                                     int                                     *arr,                                     int                                     n)                       
                         {                       
                                                 // Traverse all array elements                       
                                                 int                                     i = 0;                       
                                                 while                                     (i<n)                       
                                                 {                       
                                                 // If this element is already processed,                       
                                                 // then nothing to do                       
                                                 if                                     (arr[i] <= 0)                       
                                                 {                       
                                                 i++;                       
                                                 continue                                     ;                       
                                                 }                       
           
                                                 // Find index corresponding to this element                       
                                                 // For example, index for 5 is 4                       
                                                 int                                     elementIndex = arr[i]-1;                       
           
                                                 // If the elementIndex has an element that is not                       
                                                 // processed yet, then first store that element                       
                                                 // to arr[i] so that we don't lose anything.                       
                                                 if                                     (arr[elementIndex] > 0)                       
                                                 {                       
                                                 arr[i] = arr[elementIndex];                       
           
                                                 // After storing arr[elementIndex], change it                       
                                                 // to store initial count of 'arr[i]'                       
                                                 arr[elementIndex] = -1;                       
                                                 }                       
                                                 else                       
                                                 {                       
                                                 // If this is NOT first occurrence of arr[i],                       
                                                 // then decrement its count.                       
                                                 arr[elementIndex]--;                       
           
                                                 // And initialize arr[i] as 0 means the element                       
                                                 // 'i+1' is not seen so far                       
                                                 arr[i] = 0;                       
                                                 i++;                       
                                                 }                       
                                                 }                       
           
                                                 printf                                     (                                     "Below are counts of all elements"                                     );                       
                                                 for                                     (                                     int                                     i=0; i<n; i++)                       
                                                 printf                                     (                                     "%d -> %d"                                     , i+1,                                     abs                                     (arr[i]));                       
                         }                       
           
                         // Driver program to test above function                       
                         int                                     main()                       
                         {                       
                                                 int                                     arr[] = {2, 3, 3, 2, 5};                       
                                                 findCounts(arr,                                     sizeof                                     (arr)/                                     sizeof                                     (arr[0]));                       
           
                                                 int                                     arr1[] = {1};                       
                                                 findCounts(arr1,                                     sizeof                                     (arr1)/                                     sizeof                                     (arr1[0]));                       
           
                                                 int                                     arr3[] = {4, 4, 4, 4};                       
                                                 findCounts(arr3,                                     sizeof                                     (arr3)/                                     sizeof                                     (arr3[0]));                       
           
                                                 int                                     arr2[] = {1, 3, 5, 7, 9, 1, 3, 5, 7, 9, 1};                       
                                                 findCounts(arr2,                                     sizeof                                     (arr2)/                                     sizeof                                     (arr2[0]));                       
           
                                                 int                                     arr4[] = {3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3};                       
                                                 findCounts(arr4,                                     sizeof                                     (arr4)/                                     sizeof                                     (arr4[0]));                       
           
                                                 int                                     arr5[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};                       
                                                 findCounts(arr5,                                     sizeof                                     (arr5)/                                     sizeof                                     (arr5[0]));                       
           
                                                 int                                     arr6[] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};                       
                                                 findCounts(arr6,                                     sizeof                                     (arr6)/                                     sizeof                                     (arr6[0]));                       
           
                                                 return                                     0;                       
                         }                       

JAVA

                         // Java program to print frequencies of all array                       
                         // elements in O(1) extra space and O(n) time                       
           
                         class                                     CountFrequencies                       
                         {                       
                                                 // Function to find counts of all elements present in                       
                                                 // arr[0..n-1]. The array elements must be range from                       
                                                 // 1 to n                       
                                                 void                                     findCounts(                                     int                                     arr[],                                     int                                     n)                       
                                                 {                       
                                                 // Traverse all array elements                       
                                                 int                                     i =                                     0                                     ;                       
                                                 while                                     (i < n)                       
                                                 {                       
                                                 // If this element is already processed,                       
                                                 // then nothing to do                       
                                                 if                                     (arr[i] <=                                     0                                     )                       
                                                 {                       
                                                 i++;                       
                                                 continue                                     ;                       
                                                 }                       
           
                                                 // Find index corresponding to this element                       
                                                 // For example, index for 5 is 4                       
                                                 int                                     elementIndex = arr[i] -                                     1                                     ;                       
           
                                                 // If the elementIndex has an element that is not                       
                                                 // processed yet, then first store that element                       
                                                 // to arr[i] so that we don't lose anything.                       
                                                 if                                     (arr[elementIndex] >                                     0                                     )                       
                                                 {                       
                                                 arr[i] = arr[elementIndex];                       
           
                                                 // After storing arr[elementIndex], change it                       
                                                 // to store initial count of 'arr[i]'                       
                                                 arr[elementIndex] = -                                     1                                     ;                       
                                                 }                       
                                                 else                       
                                                 {                       
                                                 // If this is NOT first occurrence of arr[i],                       
                                                 // then decrement its count.                       
                                                 arr[elementIndex]--;                       
           
                                                 // And initialize arr[i] as 0 means the element                       
                                                 // 'i+1' is not seen so far                       
                                                 arr[i] =                                     0                                     ;                       
                                                 i++;                       
                                                 }                       
                                                 }                       
           
                                                 System.out.println(                                     "Below are counts of all elements"                                     );                       
                                                 for                                     (                                     int                                     j =                                     0                                     ; j < n; j++)                       
                                                 System.out.println(j+                                     1                                     +                                     "->"                                     + Math.abs(arr[j]));                       
                                                 }                       
           
                                                 // Driver program to test above functions                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 CountFrequencies count =                                     new                                     CountFrequencies();                       
                                                 int                                     arr[] = {                                     2                                     ,                                     3                                     ,                                     3                                     ,                                     2                                     ,                                     5                                     };                       
                                                 count.findCounts(arr, arr.length);                       
           
                                                 int                                     arr1[] = {                                     1                                     };                       
                                                 count.findCounts(arr1, arr1.length);                       
           
                                                 int                                     arr3[] = {                                     4                                     ,                                     4                                     ,                                     4                                     ,                                     4                                     };                       
                                                 count.findCounts(arr3, arr3.length);                       
           
                                                 int                                     arr2[] = {                                     1                                     ,                                     3                                     ,                                     5                                     ,                                     7                                     ,                                     9                                     ,                                     1                                     ,                                     3                                     ,                                     5                                     ,                                     7                                     ,                                     9                                     ,                                     1                                     };                       
                                                 count.findCounts(arr2, arr2.length);                       
           
                                                 int                                     arr4[] = {                                     3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     };                       
                                                 count.findCounts(arr4, arr4.length);                       
           
                                                 int                                     arr5[] = {                                     1                                     ,                                     2                                     ,                                     3                                     ,                                     4                                     ,                                     5                                     ,                                     6                                     ,                                     7                                     ,                                     8                                     ,                                     9                                     ,                                     10                                     ,                                     11                                     };                       
                                                 count.findCounts(arr5, arr5.length);                       
           
                                                 int                                     arr6[] = {                                     11                                     ,                                     10                                     ,                                     9                                     ,                                     8                                     ,                                     7                                     ,                                     6                                     ,                                     5                                     ,                                     4                                     ,                                     3                                     ,                                     2                                     ,                                     1                                     };                       
                                                 count.findCounts(arr6, arr6.length);                       
                                                 }                       
                         }                       
           
                         // This code has been contributed by Mayank Jaiswal(mayank_24)                       

Python3

                         # Python3 program to print frequencies of all array                       
                         # elements in O(1) extra space and O(n) time                       
           
                         # Function to find counts of all elements present in                       
                         # arr[0..n-1]. The array elements must be range from                       
                         # 1 to n                       
                         def                                     findCounts(arr, n):                       
                                   
                                                 # Traverse all array elements                       
                                                 i                                     =                                     0                       
                                                 while                                     i<n:                       
                                   
                                                 # If this element is already processed,                       
                                                 # then nothing to do                       
                                                 if                                     arr[i] <                                     =                                     0                                     :                       
                                                 i                                     +                                     =                                     1                       
                                                 continue                       
           
                                                 # Find index corresponding to this element                       
                                                 # For example, index for 5 is 4                       
                                                 elementIndex                                     =                                     arr[i]                                     -                                     1                       
           
                                                 # If the elementIndex has an element that is not                       
                                                 # processed yet, then first store that element                       
                                                 # to arr[i] so that we don't lose anything.                       
                                                 if                                     arr[elementIndex] >                                     0                                     :                       
                                                 arr[i]                                     =                                     arr[elementIndex]                       
           
                                                 # After storing arr[elementIndex], change it                       
                                                 # to store initial count of 'arr[i]'                       
                                                 arr[elementIndex]                                     =                                     -                                     1                       
                                   
                                                 else                                     :                       
                                   
                                                 # If this is NOT first occurrence of arr[i],                       
                                                 # then decrement its count.                       
                                                 arr[elementIndex]                                     -                                     =                                     1                       
           
                                                 # And initialize arr[i] as 0 means the element                       
                                                 # 'i+1' is not seen so far                       
                                                 arr[i]                                     =                                     0                       
                                                 i                                     +                                     =                                     1                       
           
                                                 print                                     (                                     "Below are counts of all elements"                                     )                       
                                                 for                                     i                                     in                                     range                                     (                                     0                                     ,n):                       
                                                 print                                     (                                     "%d -> %d"                                     %                                     (i                                     +                                     1                                     ,                                     abs                                     (arr[i])))                       
                                                 print                                     ("")                       
           
                         # Driver program to test above function                       
                         arr                                     =                                     [                                     2                                     ,                                     3                                     ,                                     3                                     ,                                     2                                     ,                                     5                                     ]                       
                         findCounts(arr,                                     len                                     (arr))                       
           
                         arr1                                     =                                     [                                     1                                     ]                       
                         findCounts(arr1,                                     len                                     (arr1))                       
           
                         arr3                                     =                                     [                                     4                                     ,                                     4                                     ,                                     4                                     ,                                     4                                     ]                       
                         findCounts(arr3,                                     len                                     (arr3))                       
           
                         arr2                                     =                                     [                                     1                                     ,                                     3                                     ,                                     5                                     ,                                     7                                     ,                                     9                                     ,                                     1                                     ,                                     3                                     ,                                     5                                     ,                                     7                                     ,                                     9                                     ,                                     1                                     ]                       
                         findCounts(arr2,                                     len                                     (arr2))                       
           
                         arr4                                     =                                     [                                     3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ,                                     3                                     ]                       
                         findCounts(arr4,                                     len                                     (arr4))                       
           
                         arr5                                     =                                     [                                     1                                     ,                                     2                                     ,                                     3                                     ,                                     4                                     ,                                     5                                     ,                                     6                                     ,                                     7                                     ,                                     8                                     ,                                     9                                     ,                                     10                                     ,                                     11                                     ]                       
                         findCounts(arr5,                                     len                                     (arr5))                       
           
                         arr6                                     =                                     [                                     11                                     ,                                     10                                     ,                                     9                                     ,                                     8                                     ,                                     7                                     ,                                     6                                     ,                                     5                                     ,                                     4                                     ,                                     3                                     ,                                     2                                     ,                                     1                                     ]                       
                         findCounts(arr6,                                     len                                     (arr6))                       
           
                         # This code is contributed                       
                         # by shreyanshi_19                       

C#

                         // C# program to print frequencies of                       
                         // all array elements in O(1) extra                       
                         // space and O(n) time                       
                         using                                     System;                       
           
                         class                                     GFG                       
                         {                       
                         // Function to find counts of all                       
                         // elements present in arr[0..n-1].                       
                         // The array elements must be range                       
                         // from 1 to n                       
                         void                                     findCounts(                                     int                                     [] arr,                                     int                                     n)                       
                         {                       
                                                 // Traverse all array elements                       
                                                 int                                     i = 0;                       
                                                 while                                     (i < n)                       
                                                 {                       
                                                 // If this element is already                       
                                                 // processed, then nothing to do                       
                                                 if                                     (arr[i] <= 0)                       
                                                 {                       
                                                 i++;                       
                                                 continue                                     ;                       
                                                 }                       
           
                                                 // Find index corresponding to                       
                                                 // this element. For example,                       
                                                 // index for 5 is 4                       
                                                 int                                     elementIndex = arr[i] - 1;                       
           
                                                 // If the elementIndex has an element                       
                                                 // that is not processed yet, then                       
                                                 // first store that element to arr[i]                       
                                                 // so that we don't loose anything.                       
                                                 if                                     (arr[elementIndex] > 0)                       
                                                 {                       
                                                 arr[i] = arr[elementIndex];                       
           
                                                 // After storing arr[elementIndex],                       
                                                 // change it to store initial count                       
                                                 // of 'arr[i]'                       
                                                 arr[elementIndex] = -1;                       
                                                 }                       
                                                 else                       
                                                 {                       
                                                 // If this is NOT first occurrence                       
                                                 // of arr[i], then decrement its count.                       
                                                 arr[elementIndex]--;                       
           
                                                 // And initialize arr[i] as 0 means                       
                                                 // the element 'i+1' is not seen so far                       
                                                 arr[i] = 0;                       
                                                 i++;                       
                                                 }                       
                                                 }                       
           
                                                 Console.Write(                                     "Below are counts of "                                     +                       
                                                 "all elements"                                     +                                     ""                                     );                       
                                                 for                                     (                                     int                                     j = 0; j < n; j++)                       
                                                 Console.Write(j + 1 +                                     "->"                                     +                       
                                                 Math.Abs(arr[j]) +                                     ""                                     );                       
                         }                       
           
                         // Driver Code                       
                         public                                     static                                     void                                     Main()                       
                         {                       
                                                 GFG count =                                     new                                     GFG();                       
                                                 int                                     [] arr = {2, 3, 3, 2, 5};                       
                                                 count.findCounts(arr, arr.Length);                       
           
                                                 int                                     [] arr1 = {1};                       
                                                 count.findCounts(arr1, arr1.Length);                       
           
                                                 int                                     [] arr3 = {4, 4, 4, 4};                       
                                                 count.findCounts(arr3, arr3.Length);                       
           
                                                 int                                     [] arr2 = {1, 3, 5, 7, 9, 1,                       
                                                 3, 5, 7, 9, 1};                       
                                                 count.findCounts(arr2, arr2.Length);                       
           
                                                 int                                     [] arr4 = {3, 3, 3, 3, 3,                       
                                                 3, 3, 3, 3, 3, 3};                       
                                                 count.findCounts(arr4, arr4.Length);                       
           
                                                 int                                     [] arr5 = {1, 2, 3, 4, 5, 6,                       
                                                 7, 8, 9, 10, 11};                       
                                                 count.findCounts(arr5, arr5.Length);                       
           
                                                 int                                     [] arr6 = {11, 10, 9, 8, 7, 6,                       
                                                 5, 4, 3, 2, 1};                       
                                                 count.findCounts(arr6, arr6.Length);                       
                         }                       
                         }                       
           
                         // This code is contributed by ChitraNayal                       

Javascript

                         <script>                       
           
                         // Javascript program to print frequencies                       
                         // of all array elements in O(1) extra                       
                         // space and O(n) time                       
           
                         // Function to find counts of all elements                       
                         // present in arr[0..n-1]. The array                       
                         // elements must be range from 1 to n                       
                         function                                     findCounts(arr, n)                       
                         {                       
                                   
                                                 // Traverse all array elements                       
                                                 let i = 0;                       
                                   
                                                 while                                     (i < n)                       
                                                 {                       
                                   
                                                 // If this element is already processed,                       
                                                 // then nothing to do                       
                                                 if                                     (arr[i] <= 0)                       
                                                 {                       
                                                 i++;                       
                                                 continue                                     ;                       
                                                 }                       
           
                                                 // Find index corresponding to this element                       
                                                 // For example, index for 5 is 4                       
                                                 let elementIndex = arr[i] - 1;                       
           
                                                 // If the elementIndex has an element that                       
                                                 // is not processed yet, then first store                       
                                                 // that element to arr[i] so that we don't                       
                                                 // lose anything.                       
                                                 if                                     (arr[elementIndex] > 0)                       
                                                 {                       
                                                 arr[i] = arr[elementIndex];                       
           
                                                 // After storing arr[elementIndex],                       
                                                 // change it to store initial count                       
                                                 // of 'arr[i]'                       
                                                 arr[elementIndex] = -1;                       
                                                 }                       
                                                 else                       
                                                 {                       
                                   
                                                 // If this is NOT first occurrence                       
                                                 // of arr[i], then decrement its count.                       
                                                 arr[elementIndex]--;                       
           
                                                 // And initialize arr[i] as 0 means                       
                                                 // the element 'i+1' is not seen so far                       
                                                 arr[i] = 0;                       
                                                 i++;                       
                                                 }                       
                                                 }                       
           
                                                 document.write(                                     "<br>Below are counts of all elements<br>"                                     );                       
                                                 for                                     (let j = 0; j < n; j++)                       
                                                 document.write(j+1 +                                     "->"                                     +                       
                                                 Math.abs(arr[j]) +                                     "<br>"                                     );                       
                         }                       
           
                         // Driver code                       
                         let arr = [ 2, 3, 3, 2, 5 ];                       
                         findCounts(arr, arr.length);                       
           
                         let arr1 = [ 1 ];                       
                         findCounts(arr1, arr1.length);                       
           
                         let arr3 = [ 4, 4, 4, 4 ];                       
                         findCounts(arr3, arr3.length);                       
           
                         let arr2 = [ 1, 3, 5, 7, 9, 1, 3, 5, 7, 9, 1 ];                       
                         findCounts(arr2, arr2.length);                       
           
                         let arr4 = [ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 ];                       
                         findCounts(arr4, arr4.length);                       
           
                         let arr5 = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 ];                       
                         findCounts(arr5, arr5.length);                       
           
                         let arr6 = [ 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ];                       
                         findCounts(arr6, arr6.length);                       
           
                         // This code is contributed by unknown2108                       
           
                         </script>                       

输出：

Below are counts of all elements1 -> 02 -> 23 -> 24 -> 05 -> 1Below are counts of all elements1 -> 1Below are counts of all elements1 -> 02 -> 03 -> 04 -> 4Below are counts of all elements1 -> 32 -> 03 -> 24 -> 05 -> 26 -> 07 -> 28 -> 09 -> 210 -> 011 -> 0Below are counts of all elements1 -> 02 -> 03 -> 114 -> 05 -> 06 -> 07 -> 08 -> 09 -> 010 -> 011 -> 0Below are counts of all elements1 -> 12 -> 13 -> 14 -> 15 -> 16 -> 17 -> 18 -> 19 -> 110 -> 111 -> 1Below are counts of all elements1 -> 12 -> 13 -> 14 -> 15 -> 16 -> 17 -> 18 -> 19 -> 110 -> 111 -> 1

复杂性分析：
- 时间复杂性： O（n）。因为数组的一次遍历需要O（n）个时间。
- 空间复杂性： O（1）。因为不需要额外的空间。

方法3 : 通过添加“n”来跟踪计数。

方法： 所有数组元素从1到n。将每个元素减少1。数组元素现在在0到n-1的范围内，所以可以说对于每个索引i， 楼层（阵列[i]/n）=0 . 如前所述，我们的想法是遍历给定的数组，使用元素作为索引，并将它们的计数存储在索引中。考虑基本方法，需要一个大小n的哈希图，数组也是大小n。因此数组可以用作哈希图，但不同之处在于，代替元素将n添加到 数组[i]th 指数所以在更新了 数组[i]%n 将给出第i个元素和 数组[i]/n 将给出i+1的频率。

图片[2]-在O（1）额外空间和O（n）时间内计算阵列中所有元素的频率-yiteyi-C++库

算法：
1. 从头到尾遍历数组，将所有元素减少1。
2. 再次从头到尾遍历数组。
3. 对于每个元素 数组[i]%n 使现代化 数组[array[i]%n] ，即 数组[array[i]%n]++
4. 从头到尾遍历数组并打印 i+1 作为价值和 数组[i]/n 作为频率。
实施：

C++

                         // C++ program to print frequencies of all array                       
                         // elements in O(1) extra space and O(n) time                       
                         #include<bits/stdc++.h>                       
                         using                                     namespace                                     std;                       
           
                         // Function to find counts of all elements present in                       
                         // arr[0..n-1]. The array elements must be range from                       
                         // 1 to n                       
                         void                                     printfrequency(                                     int                                     arr[],                                     int                                     n)                       
                         {                       
                                                 // Subtract 1 from every element so that the elements                       
                                                 // become in range from 0 to n-1                       
                                                 for                                     (                                     int                                     j =0; j<n; j++)                       
                                                 arr[j] = arr[j]-1;                       
           
                                                 // Use every element arr[i] as index and add 'n' to                       
                                                 // element present at arr[i]%n to keep track of count of                       
                                                 // occurrences of arr[i]                       
                                                 for                                     (                                     int                                     i=0; i<n; i++)                       
                                                 arr[arr[i]%n] = arr[arr[i]%n] + n;                       
           
                                                 // To print counts, simply print the number of times n                       
                                                 // was added at index corresponding to every element                       
                                                 for                                     (                                     int                                     i =0; i<n; i++)                       
                                                 cout << i + 1 <<                                     " ->  "                                     << arr[i]/n << endl;                       
                         }                       
           
                         // Driver program to test above function                       
                         int                                     main()                       
                         {                       
                                                 int                                     arr[] = {2, 3, 3, 2, 5};                       
                                                 int                                     n =                                     sizeof                                     (arr)/                                     sizeof                                     (arr[0]);                       
                                                 printfrequency(arr,n);                       
                                                 return                                     0;                       
                         }                       

JAVA

                         class                                     CountFrequency                       
                         {                       
                                                 // Function to find counts of all elements present in                       
                                                 // arr[0..n-1]. The array elements must be range from                       
                                                 // 1 to n                       
                                                 void                                     printfrequency(                                     int                                     arr[],                                     int                                     n)                       
                                                 {                       
                                                 // Subtract 1 from every element so that the elements                       
                                                 // become in range from 0 to n-1                       
                                                 for                                     (                                     int                                     j =                                     0                                     ; j < n; j++)                       
                                                 arr[j] = arr[j] -                                     1                                     ;                       
           
                                                 // Use every element arr[i] as index and add 'n' to                       
                                                 // element present at arr[i]%n to keep track of count of                       
                                                 // occurrences of arr[i]                       
                                                 for                                     (                                     int                                     i =                                     0                                     ; i < n; i++)                       
                                                 arr[arr[i] % n] = arr[arr[i] % n] + n;                       
           
                                                 // To print counts, simply print the number of times n                       
                                                 // was added at index corresponding to every element                       
                                                 for                                     (                                     int                                     i =                                     0                                     ; i < n; i++)                       
                                                 System.out.println(i +                                     1                                     +                                     "->"                                     + arr[i] / n);                       
                                                 }                       
           
                                                 // Driver program to test above functions                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 CountFrequency count =                                     new                                     CountFrequency();                       
                                                 int                                     arr[] = {                                     2                                     ,                                     3                                     ,                                     3                                     ,                                     2                                     ,                                     5                                     };                       
                                                 int                                     n = arr.length;                       
                                                 count.printfrequency(arr, n);                       
                                                 }                       
                         }                       
           
                         // This code has been contributed by Mayank Jaiswal                       

Python3

                         # Python 3 program to print frequencies                       
                         # of all array elements in O(1) extra                       
                         # space and O(n) time                       
           
                         # Function to find counts of all elements                       
                         # present in arr[0..n-1]. The array                       
                         # elements must be range from 1 to n                       
                         def                                     printfrequency(arr, n):                       
           
                                                 # Subtract 1 from every element so that                       
                                                 # the elements become in range from 0 to n-1                       
                                                 for                                     j                                     in                                     range                                     (n):                       
                                                 arr[j]                                     =                                     arr[j]                                     -                                     1                       
           
                                                 # Use every element arr[i] as index                       
                                                 # and add 'n' to element present at                       
                                                 # arr[i]%n to keep track of count of                       
                                                 # occurrences of arr[i]                       
                                                 for                                     i                                     in                                     range                                     (n):                       
                                                 arr[arr[i]                                     %                                     n]                                     =                                     arr[arr[i]                                     %                                     n]                                     +                                     n                       
           
                                                 # To print counts, simply print the                       
                                                 # number of times n was added at index                       
                                                 # corresponding to every element                       
                                                 for                                     i                                     in                                     range                                     (n):                       
                                                 print                                     (i                                     +                                     1                                     ,                                     "->"                                     , arr[i]                                     /                                     /                                     n)                       
           
                         # Driver code                       
                         arr                                     =                                     [                                     2                                     ,                                     3                                     ,                                     3                                     ,                                     2                                     ,                                     5                                     ]                       
                         n                                     =                                     len                                     (arr)                       
                         printfrequency(arr, n)                       
           
                         # This code is contributed                       
                         # by Shrikant13                       

C#

                         using                                     System;                       
           
                         internal                                     class                                     CountFrequency                       
                         {                       
                                                 // Function to find counts of all elements present in                       
                                                 // arr[0..n-1]. The array elements must be range from                       
                                                 // 1 to n                       
                                                 internal                                     virtual                                     void                                     printfrequency(                                     int                                     [] arr,                                     int                                     n)                       
                                                 {                       
                                                 // Subtract 1 from every element so that the elements                       
                                                 // become in range from 0 to n-1                       
                                                 for                                     (                                     int                                     j = 0; j < n; j++)                       
                                                 {                       
                                                 arr[j] = arr[j] - 1;                       
                                                 }                       
           
                                                 // Use every element arr[i] as index and add 'n' to                       
                                                 // element present at arr[i]%n to keep track of count of                       
                                                 // occurrences of arr[i]                       
                                                 for                                     (                                     int                                     i = 0; i < n; i++)                       
                                                 {                       
                                                 arr[arr[i] % n] = arr[arr[i] % n] + n;                       
                                                 }                       
           
                                                 // To print counts, simply print the number of times n                       
                                                 // was added at index corresponding to every element                       
                                                 for                                     (                                     int                                     i = 0; i < n; i++)                       
                                                 {                       
                                                 Console.WriteLine(i + 1 +                                     "->"                                     + arr[i] / n);                       
                                                 }                       
                                                 }                       
           
                                                 // Driver program to test above functions                       
                                                 public                                     static                                     void                                     Main(                                     string                                     [] args)                       
                                                 {                       
                                                 CountFrequency count =                                     new                                     CountFrequency();                       
                                                 int                                     [] arr =                                     new                                     int                                     [] {2, 3, 3, 2, 5};                       
                                                 int                                     n = arr.Length;                       
                                                 count.printfrequency(arr, n);                       
                                                 }                       
                         }                       
           
                         // This code is contributed by Shrikant13                       

PHP

                         <?php                       
                         // PHP program to print                       
                         // frequencies of all                       
                         // array elements in O(1)                       
                         // extra space and O(n) time                       
           
                         // Function to find counts                       
                         // of all elements present                       
                         // in arr[0..n-1]. The array                       
                         // elements must be range                       
                         // from 1 to n                       
                         function                                     printfrequency(                                     $arr                                     ,                                     $n                                     )                       
                         {                       
                                                 // Subtract 1 from every                       
                                                 // element so that the                       
                                                 // elements become in                       
                                                 // range from 0 to n-1                       
                                                 for                                     (                                     $j                                     = 0;                                     $j                                     <                                     $n                                     ;                                     $j                                     ++)                       
                                                 $arr                                     [                                     $j                                     ] =                                     $arr                                     [                                     $j                                     ] - 1;                       
           
                                                 // Use every element arr[i]                       
                                                 // as index and add 'n' to                       
                                                 // element present at arr[i]%n                       
                                                 // to keep track of count of                       
                                                 // occurrences of arr[i]                       
                                                 for                                     (                                     $i                                     = 0;                                     $i                                     <                                     $n                                     ;                                     $i                                     ++)                       
                                                 $arr                                     [                                     $arr                                     [                                     $i                                     ] %                                     $n                                     ] =                       
                                                 $arr                                     [                                     $arr                                     [                                     $i                                     ] %                                     $n                                     ] +                                     $n                                     ;                       
           
                                                 // To print counts, simply                       
                                                 // print the number of times                       
                                                 // n was added at index                       
                                                 // corresponding to every element                       
                                                 for                                     (                                     $i                                     = 0;                                     $i                                     <                                     $n                                     ;                                     $i                                     ++)                       
                                                 echo                                     $i                                     + 1,                                     " -> "                                     ,                       
                                                 (int)(                                     $arr                                     [                                     $i                                     ] /                                     $n                                     ) ,                                     ""                                     ;                       
                         }                       
           
                         // Driver Code                       
                         $arr                                     =                                     array                                     (2, 3, 3, 2, 5);                       
                         $n                                     = sizeof(                                     $arr                                     );                       
                         printfrequency(                                     $arr                                     ,                                     $n                                     );                       
           
                         // This code is contributed by ajit                       
                         ?>                       

Javascript

                         <script>                       
                                                 // Function to find counts of all elements present in                       
                                                 // arr[0..n-1]. The array elements must be range from                       
                                                 // 1 to n                       
                                   
                                                 function                                     printfrequency(arr, n)                       
                                                 {                       
                                   
                                                 // Subtract 1 from every element so that the elements                       
                                                 // become in range from 0 to n-1                       
                                                 for                                     (let j = 0; j < n; j++)                       
                                                 arr[j] = arr[j] - 1;                       
                                   
                                                 // Use every element arr[i] as index and add 'n' to                       
                                                 // element present at arr[i]%n to keep track of count of                       
                                                 // occurrences of arr[i]                       
                                                 for                                     (let i = 0; i < n; i++)                       
                                                 arr[arr[i] % n] = arr[arr[i] % n] + n;                       
                                   
                                                 // To print counts, simply print the number of times n                       
                                                 // was added at index corresponding to every element                       
                                                 for                                     (let i = 0; i < n; i++)                       
                                                 document.write((i + 1) +                                     " -> "                                     + parseInt(arr[i] / n, 10) +                                     "</br>"                                     );                       
                                                 }                       
                                   
                                                 let arr = [2, 3, 3, 2, 5];                       
                                                 let n = arr.length;                       
                                                 printfrequency(arr, n);                       
                                   
                                                 // This code is contributed by divyeshrabadiya07.                       
                         </script>                       

输出：

1 ->  02 ->  23 ->  24 ->  05 ->  1

复杂性分析：
- 时间复杂性： O（n）。只需要两次遍历数组，一次遍历数组需要O（n）个时间。
- 空间复杂性： O（1）。因为不需要额外的空间。

感谢Vivek Kumar在下面的评论中提出这个解决方案。

本文由Shubham Gupta撰稿。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写评论

文章版权归作者所有，未经允许请勿转载。

THE END

技术文章