【项目总结】性能优化之算法优化

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/It_sharp/article/details/82852498

源头

            GroupPassRate groupPassRate = new GroupPassRate();
            groupPassRate.Groups = arrClass;
            groupPassRate.Files = arrFile;
            groupPassRate.PassRateArray = new PassRateBase[arrClass.Count][];
            for (int nRow = 0; nRow < arrClass.Count; nRow++)
            {
                groupPassRate.PassRateArray[nRow] = new PassRateBase[arrFile.Count];
                for (int nCol = 0; nCol < arrFile.Count; nCol++)
                {
                    //计算每个分类每次测量的合格率
                    groupPassRate.PassRateArray[nRow][nCol] = StatPassRate(arrFile[nCol].FileID, arrClass[nRow].ClassID, bFD);
                }
            }
            return groupPassRate;

这里计算每个分类的每次测量的合格率每次都要去数据库查一次这个文件的这个分类的测量数据，假如有20个分类，10个文件，每个文件有1000条数据。因为数据库查找是全表扫描，所以查找一个分类要10*1000次数，所以慢。

办法

这个是名义值的数据结构

    public class DM_ModelNominal
    {
        public UInt32 NominalID;        //ID
        public UInt32 PointID;          //测点ID

        public float Nominal;           //名义值
        public float UpTol;             //上公差
        public float LowTol;            //测量数据类型

        public float CenterCtrl;        //中心线
        public float UpCtrl;            //上控制线
        public float LowCtrl;           //下控制线

        public int NominalType;         //名义值类型
        public int Status;              //修改状态

        public string PointDir;         //测点名称和特征
        public string DirName;	        //方向   
        public string RelationPoint;    //相关点

        public string Description = "";
    }

这个是提前查出来的矩阵数据

    public class DM_MeasureMatrix
    {
        //NominalArray和FileArray必须是有序的,分别按NominalID和FileID排序
        public List<DM_ModelNominal>     NominalArray = null; 
        public List<DM_ModelMeasureFile> FileArray = null;

        protected UInt32[] m_arrNominalID = null;
        protected UInt32[] m_arrFileID = null;
        protected int[] m_arrRowIndex = null;
        protected int[] m_arrColIndex = null;
        protected float[] m_arrData = null;
        private const float NULL_VALUE = -999;
        public int Cols{ ... ... }
        public int Rows{ ... ... }
        //构建矩阵
        public void MakeMatrix(){ ... ...}
        public void Sort(bool bSortDate, bool bSortNominal){ ... ...}
        private void SortFile() { ... ...}
        private void SortNominal(){ ... ... }
        //增加测量值
        public void AddValue(UInt32 nNominalID, UInt32 nFileID, float fValue){ ... ...}
        //查找名义值行索引
        protected int FindNominal(UInt32 nNominalID){ ... ... }
        //取得值
        public float GetValue(int nRow, int nCol){ ... ... }
        public DM_ModelNominal GetNominal(int nRow){ ... ... }
        public DM_ModelNominal GetNominalByID(UInt32 nNominalID){ ... ... }
        public DM_ModelMeasureFile GetFile(int nCol) { ... ... }
        public DM_ModelMeasureFile GetFileByID(UInt32 nFileID){ ... ... }
        //判断测量数据是否为空
        public bool IsDataNull(int nRow, int nCol) { ... ... }
        //查找文件列索引
        protected int FindFile(UInt32 nFileID) { ... ... }
    }

现在就是要得到区域合格率
优化办法就是：
查出ClassPoint表

ClassID	ClassPointID	PointID
…	…	…

ClassID和PointID的映射关系是多对多
DM_ModelNominal类里面也有PointID映射到NominalID，关系是多对一
可以建立ClassID到NominalID的映射关系

for(int i=0;i<ClassPoint.Count;i++)//20
{
	for( int j=0; j<ModelNomial.Count; j++)//400
	{
		if(ClassPoint[i].PointID == ModelNominal[j].PointID)
		{
			for(查找到NominalID下对应的Nominal值)//1000个nominal值
			{
				Model model = new Model( ){ 分类名称="侧墙" , 总数 =0 , 合格数量=0 };
				//这里是有取数据的操作的，取得复杂度是O（1）使用HashTable时
				HashTable[ClassID].总数++;
				if(合格)
				HasTable[ClassID].合格数量++;
			}
		}
	}
}

总结

1、数组是查找快（连续的内存），更新慢、链表是更新快，查找慢（不连续内存）
2、HashTable的查找快
3、数据结构就是排序、查找两种
归并排序、堆排序、快速排序
分别是稳定、不稳定、很不稳定
NLogN、NLogN、（N~N^2）
内存是归并需要一倍内存、堆需要。。、快速排序不需要内存