C#中怎样统计数组中一个一维数组中每个元素出现的次数?

Posted 2023-05-15

比如说一个数组1,9,3,5,4,1,1,9,7,9,4,7,1,3,2,2,8,9,6,8，最后统计出每个数字出现的次数！最好能详细点，能把思想表述出来！

遍历数组，并用字典集合Dictionary<T>存放每个元素出现的次数统计结果。

例如，统计一个整型数组中每个数组元素出现的次数，实现方法如下：

（1）在Visual Studio 中创建一个“控制台应用程序”项目

（2）Program.cs

using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApplication1

    class ItemInfo
    
        /// <summary>
        /// ItemInfo 类记录数组元素重复次数
        /// </summary>
        /// <param name="value">数组元素值</param>
        public ItemInfo(int value)
        
            Value = value;
            RepeatNum = 1;
        
        /// <summary>
        /// 数组元素的值
        /// </summary>
        public int Value  get; set; 
        /// <summary>
        /// 数组元素重复的次数
        /// </summary>
        public int RepeatNum  get; set;  
    

    class Program
    
        static void Main(string[] args)
        
            // 待统计的整型数组
            int[] a =  1, 1, 1, 3, 1, 2, 2, 1, 3, 4, 2, 1, 5, 3, 4 ;
            
            // 集合 dic 用于存放统计结果
            Dictionary<int, ItemInfo> dic = 
                new Dictionary<int, ItemInfo>();
                
            // 开始统计每个元素重复次数
            foreach (int v in a)
            
                if (dic.ContainsKey(v))
                
                    // 数组元素再次，出现次数增加 1
                    dic[v].RepeatNum += 1;
                
                else
                
                    // 数组元素首次出现，向集合中添加一个新项
                    // 注意 ItemInfo类构造函数中，已经将重复
                    // 次数设置为 1
                    dic.Add(v, new ItemInfo(v));
                
            

            foreach (ItemInfo info in dic.Values)
            
                Console.WriteLine("数组元素 0 出现的次数为 1", 
                    info.Value, info.RepeatNum);
            
        
    

（3）运行结果

参考技术A         //using System.Linq;
        static void Main(string[] args)
        
            int[] nums =  1, 9, 3, 5, 4, 1, 1, 9, 7, 9, 4, 7, 1, 3, 2, 2, 8, 9, 6, 8 ;
            foreach (var v in nums.GroupBy(x => x).Select(x => new  k = x.Key, c = x.Count() ))
                Console.WriteLine("0出现了1次", v.k, v.c);
            Console.ReadLine();
        

追问

请问您这是用了什么函数啊？

追答

linq
http://baike.baidu.com/view/965131.htm?fr=aladdin

本回答被提问者和网友采纳 参考技术B var data = new int[]  1, 9, 3, 5, 4, 1, 1, 9, 7, 9, 4, 7, 1, 3, 2, 2, 8, 9, 6, 8 ;
var lst = from v in data
          group v by v into G
          orderby G.Key
          select new
          
              data = G.Key,
              count = G.Count()
          ;

foreach (var v in lst)

    Console.WriteLine("0:1次", v.data, v.count);

将数组中的数字按照自身分组统计，然后排序输出

如果全部手动的话，可以借助dictionary<>：

var data = new int[]  1, 9, 3, 5, 4, 1, 1, 9, 7, 9, 4, 7, 1, 3, 2, 2, 8, 9, 6, 8 ;
var dict = new Dictionary<int, int>();
foreach (var v in data)

    if (!dict.ContainsKey(v))
        dict.Add(v, 0);
    dict[v]++;

foreach (var v in dict)

    Console.WriteLine("0:1次",v.Key,v.Value);

对于每个元素，如果不存在在字典中，则添加进去，然后将该项目+1

参考技术C 你可以再建立一个哈希表，然后循环你的数组，比如第一个元素，判断哈希表中是否存在该key（1），如果没有1，那么就说明这是新的元素，那么在哈希表中插入元素，value = 1；再向下循环，还是判断9是否存在，如果存在value++，如果不存在则value=1，这样就能统计出每个元素的个数了。

reduce()方法：求和求乘积数组中每个元素出现的次数去重二维和多维数组转为一维数组

作用：

reduce() 方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。
reduce() 可以作为一个高阶函数，用于函数的 compose。
常被用来求和与求乘积

语法：

array.reduce(function(total, currentValue, currentIndex, arr), initialValue)

• total，必需。初始值, 或者计算结束后的返回值。
• currentValue，必需。当前元素
• currentIndex，可选。当前元素的索引
• arr，可选。当前元素所属的数组对象。
• initialValue,可选。传递给函数的初始值(默认为第一个数值）

注意：

reduce() 对于空数组是不会执行回调函数的。

实例：

//求和
let arr= [1,2,3,4]; 
let data1 = arr.reduce((prev, cur, index, arr) => {
    console.log(prev, cur, index);
    return prev + cur;
})
console.log(arr,data1)
//打印结果：
1 2 1
3 3 2
6 4 3
[1, 2, 3, 4] 10

//乘积
let data2 = arr.reduce((prev, cur, index, arr) => {
    console.log(prev, cur, index);
    return prev * cur;
})
console.log(arr,data2)
//打印结果：
1 2 1
5 2 3 2
5 6 4 3
[1, 2, 3, 4] 24

拓展：

//计算数组中每个元素出现的次数
let names = [\'Alice\', \'Bob\', \'Tiff\', \'Bruce\', \'Alice\'];
let nameNum = names.reduce((pre,cur)=>{
  if(cur in pre){
    pre[cur]++
  }else{
    pre[cur] = 1 
  }
  return pre
},{})
console.log(nameNum); //{Alice: 2, Bob: 1, Tiff: 1, Bruce: 1}

//数组去重
let arr = [1,2,3,4,4,1]
let newArr = arr.reduce((pre,cur)=>{
    if(!pre.includes(cur)){
      return pre.concat(cur)
    }else{
      return pre
    }
},[])
console.log(newArr);// [1, 2, 3, 4]

//将二维数组转化为一维
let arr = [[0, 1], [2, 3], [4, 5]]
let newArr = arr.reduce((pre,cur)=>{
    return pre.concat(cur)
},[])
console.log(newArr); // [0, 1, 2, 3, 4, 5]

//将多维数组转化为一维
let arr = [[0, 1], [2, 3], [4,[5,6,7]]]
const newArr = function(arr){
   return arr.reduce((pre,cur)=>pre.concat(Array.isArray(cur)?newArr(cur):cur),[])
}
console.log(newArr(arr)); //[0, 1, 2, 3, 4, 5, 6, 7]

//对象里的属性求和
var result = [
    {
        subject: \'math\',
        score: 10
    },
    {
        subject: \'chinese\',
        score: 20
    },
    {
        subject: \'english\',
        score: 30
    }
];
var sum = result.reduce(function(prev, cur) {
    return cur.score + prev;
}, 0);
console.log(sum) //60