C# 小规模查找集合性能测试
项目中包含浮点运算，大概每秒 20 - 100 万左右. 其计算结果每秒只包含1000个左右。 因此大量运算是重复性的。程序运行时，cpu 在 3% - 10% 浮动。打算将结果缓存。根据键值索值。
目前考虑数据类型有: SortedList , SortedDictionary , Dictionary , List 。测试结果如下:
aaarticlea/png;base64,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" alt="" />
代码:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text; namespace ConsoleApplication1
{
class Program
{
static System.Random random = new Random();
static void Main(string[] args)
{
System.Threading.Thread.Sleep(1000); System.Drawing.PointF[] p = new System.Drawing.PointF[1024];
for (int i = 0; i < 1024; i++)
{
p[i] = new System.Drawing.PointF((float)random.NextDouble(), (float)random.NextDouble());
} double[] find = new double[10];
find[0] = p[10].X;
find[1] = p[800].X;
find[2] = p[200].X;
find[3] = p[199].X;
find[4] = p[485].X;
find[5] = p[874].X;
find[6] = p[912].X;
find[7] = p[110].X;
find[8] = p[12].X;
find[9] = p[600].X; testSortList(p, find);
Console.WriteLine();
testSortedDictionary(p, find);
Console.WriteLine();
testDictionary(p, find);
Console.WriteLine();
testList(p, find); Console.Read(); } static void testSortList(System.Drawing.PointF [] p , double [] find) {
SortedList<double, double> s = new SortedList<double, double>(1024); System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
stopWatch.Start();
foreach (System.Drawing.PointF sp in p)
{
s.Add(sp.X, sp.Y);
}
stopWatch.Stop();
Console.WriteLine("SortedList add:" + stopWatch.ElapsedTicks); stopWatch.Reset();
stopWatch.Start();
foreach (double d in find)
{
Console.WriteLine(s.ContainsKey(d));
}
stopWatch.Stop(); Console.WriteLine("SortedList find:" + stopWatch.ElapsedTicks);
} static void testSortedDictionary(System.Drawing.PointF[] p, double[] find)
{
SortedDictionary<double, double> s = new SortedDictionary<double, double>(); System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
stopWatch.Start();
foreach (System.Drawing.PointF sp in p)
{
s.Add(sp.X, sp.Y);
}
stopWatch.Stop();
Console.WriteLine("SortedDictionary add:" + stopWatch.ElapsedTicks); stopWatch.Reset();
stopWatch.Start();
foreach (double d in find)
{
Console.WriteLine(s.ContainsKey(d));
}
stopWatch.Stop(); Console.WriteLine("SortedDictionary find:" + stopWatch.ElapsedTicks);
} static void testDictionary(System.Drawing.PointF[] p, double[] find)
{
Dictionary<double, double> s = new Dictionary<double, double>(1024); System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
stopWatch.Start();
foreach (System.Drawing.PointF sp in p)
{
s.Add(sp.X, sp.Y);
}
stopWatch.Stop();
Console.WriteLine("Dictionary add:" + stopWatch.ElapsedTicks); stopWatch.Reset();
stopWatch.Start();
foreach (double d in find)
{
Console.WriteLine(s.ContainsKey(d));
}
stopWatch.Stop(); Console.WriteLine("Dictionary find:" + stopWatch.ElapsedTicks);
} static void testList(System.Drawing.PointF[] p, double[] find)
{ List<System.Drawing.PointF> lst = new List<System.Drawing.PointF>(); System.Diagnostics.Stopwatch stopWatch = new System.Diagnostics.Stopwatch();
stopWatch.Start();
foreach (System.Drawing.PointF sp in p)
{
lst.Add(sp);
}
stopWatch.Stop();
Console.WriteLine("List add:" + stopWatch.ElapsedTicks); stopWatch.Reset();
stopWatch.Start();
System.Drawing.PointF p2;
bool bln = false ;
foreach (double d in find)
{
p2 = lst.Find(new Predicate<System.Drawing.PointF>((p1) =>
{
return p1.X == d;
})); //foreach (System.Drawing.PointF p1 in lst)
//{
// if (p1.X == d)
// {
// bln = true;
// break;
// }
//} //for (int i = 0; i < lst.Count; i++ )
//{
// if (lst[i].X == d)
// {
// bln = true;
// break;
// }
//} if (bln)
{
Console.WriteLine("True");
bln = false;
}
else {
Console.WriteLine("False");
}
}
stopWatch.Stop(); Console.WriteLine("List find:" + stopWatch.ElapsedTicks);
} }
}
C# 小规模查找集合性能测试的更多相关文章
- 《算法导论》习题2.3-7 查找集合S中是否有两个元素和为X---Java实现
代码如下: public class MergeSort { public static void sort(int [] A,int p, int r) { if(p<r) { int q = ...
- 使用ILookup<TKey, TElement> 接口查找集合
public class Program { public static void Main() { // 创建一个放入ilookup数据结构的School清单. List<School> ...
- 遍历查找集合或者数组中的某个元素的值 java代码 详解 Android开发
import java.util.Scanner; public class Test21 { public static void main(String[] args) { //定义并初始化数组 ...
- 使用First查找集合报错：序列不包含任何匹配元素
原因其实是很简单的: 使用First代表一定能找到,找不到就抛出异常,必须使用try……catch……进行异常的捕获. 推荐使用 FirstOrDefault 或Find 取序列中满足条件的第一个元 ...
- python列表--查找集合中重复元素的个数
方法一: >>> mylist = [1,2,2,2,2,3,3,3,4,4,4,4] >>> myset = set(mylist) >>> f ...
- 读 Zepto 源码之集合元素查找
这篇依然是跟 dom 相关的方法,侧重点是跟集合元素查找相关的方法. 读Zepto源码系列文章已经放到了github上,欢迎star: reading-zepto 源码版本 本文阅读的源码为 zept ...
- 性能测试工具BenchmarkDotnet
.NET Core中的性能测试工具BenchmarkDotnet https://www.cnblogs.com/lwqlun/p/9671611.html 背景介绍 之前一篇博客中,我们讲解.NET ...
- Java中常用集合操作
一.Map 名值对存储的. 常用派生类HashMap类 添加: put(key,value)往集合里添加数据 删除: clear()删除所有 remove(key)清除单个,根据k来找 获取: siz ...
- Objective-C 数据集合
1.NSSet 1.是一个无序的,管理多个对象的集合类,最大特点 是集合中不允许出现重复对象,和数学上的集合含义是一 样的 2.除了无序.不许重复之外,其它功能和NSArray是一样的 2.NSArr ...
随机推荐
- 如何定位摄像机，使物体在屏幕上始终具有相同的像素宽度和高度？(threes)
from How to position the camera so that the object always has the same pixel width and height on the ...
- Spring Boot修改内置Tomcat端口号 (zhuan)
http://blog.csdn.net/argel_lj/article/details/49851625 ********************************************* ...
- Command设计模式
1 意图:将一个请求封装为一个对象,可以用不同的请求对客户进行参数化: 对请求排队或记录请求日志,以及支持可撤销的操作. 2 别名:Action.Transaction 3 动机:把请求变成一个对象. ...
- [转载]findContours函数参数说明及相关函数
原文地址:findContours函数参数说明及相关函数作者:鸳都学童 findContours函数,这个函数的原型为: void findContours(InputOutputArray imag ...
- c++ string 与 char 互转 以及base64
c++ string 与 char 互转 很简单如下 ] = {'A','B','C','D','E'}; printf("%s\n",bts); //char to string ...
- java 内部类1
内部类: 常用的情景:一个类要经常访问另一个类的成员. 举个例子: class人 { 血,氧气... class 心脏{...} } 内部类的优势: 成员内类,作为外部类的成员,可以方便随意的访问外部 ...
- linux笔记：linux系统安装-系统分区
分区类型: 1.主分区:最多只能有4个. 2.扩展分区:最多只能有1个:主分区+扩展分区最多有4个:不能写入数据,只能包含逻辑分区. 3.逻辑分区. 格式化: 向磁盘中写入文件系统.会附带地清空磁盘中 ...
- Nginx内置常用变量
nginx用到的全局变量 $arg_PARAMETER #这个变量包含GET请求中,如果有变量PARAMETER时的值. $args #这个变量等于请求行中(GET请求)的参数,例如foo=123&a ...
- python 练习 6
#!/usr/bin/python # -*- coding: utf-8 -*- from collections import deque from math import log10 def p ...
- Java中print、printf、println
Java中的System.out输出会用到print.println以及printf命令. 其中 print一般的标准输出,但是不换行. println对比print即在结尾处多了换行. eg:pr ...