AMS算法

 #include<stdio.h>
 #include<stdlib.h>
 #include<time.h>

 #define N 1000//采样点的个数
 #define M 5//分组

 #define SIZE 10000

 typedef struct
 {
     int element;
     int count;
 }ATTRIBUTE;

 int main()
 {
     ATTRIBUTE attr[];
     int secmom=;//真实二阶矩
     int data;//接收读取之后的值
     int i=,j,k;//循环控制变量
     int count_tmp=;//临时计数变量
     //int n=5;//采样点的个数
     double secmom_estima=;
     ATTRIBUTE sample[];
     int tmp;
     int a[];
     int loc[N];//采样位置保存在数组里
     int sample_group[M][N];
     //FILE *fp =fopen("./stream_for_ams.txt","r");

     FILE *fp =fopen("./stream_sample_ams.txt","r");

     srand(time());
     for(j=;j<N;j++)
     {
         loc[j]=rand()%SIZE;//获取随机采样位置
     }

     for(j=;j<N;j++)//随机位置排序
     {
         for(k=j+;k<N;k++)
         {
             if(loc[j] > loc[k])
             {
                 tmp = loc[k];
                 loc[k]=loc[j];
                 loc[j]=tmp;
             }
         }
     }

     if(fp == NULL)//文件读取失败
     {
         printf("file can't open!\n");
         exit();
     }
     while(!feof(fp))
     {
         fscanf(fp,"%d",&data);
         a[i]=data;//存数据
         /***************采样*****************/
         for(j=;j<N;j++)
         {
             if(loc[j] == i)
             {
                 sample[j].element=data;
                 sample[j].count=;
             }
             if(sample[j].element == data)
             {
                 sample[j].count+=;
             }
         }

         /*****************真实***********************/
         for(j=;j<count_tmp;j++)
         {
             if(attr[j].element == data)//如果该数据被存过则count+1
             {
                 attr[j].count +=;
                 break;//扫描比对成功退出循环
             }
         }
         if( j == count_tmp)//如果没有该数据第一次出现
         {
             attr[count_tmp].element=data;//记录
             attr[count_tmp].count=;
             count_tmp++;//记录第一次出现的数
         }
         printf("%.2lf%%\r", i * 100.0/ SIZE);
         i++;
     }

     /******************组合估计二阶矩***********************/
     for(i=;i<M;i++)//分组M
     {
         for(j=;j<N;j++)//每组N个随机位置
         {
             loc[j]=rand()%SIZE;//获取随机采样位置
         }
         for(j=;j<N;j++)//随机位置排序
         {
             for(k=j+;k<N;k++)
             {
                 if(loc[j] > loc[k])
                 {
                     tmp = loc[k];
                     loc[k]=loc[j];
                     loc[j]=tmp;
                 }
             }
         }
         for(j=;j<N;j++)
         {
             if(loc[j] == i)
             {
                 sample_group[i][j]=
                 sample[j].count=;
             }
             if(sample[j].element == data)
             {
                 sample[j].count+=;
             }
         }

     }

     /************估计无组合估计二阶矩**********************/
     for(j=;j<N;j++)
     {
         secmom_estima+=SIZE*(2.0*sample[j].count-);
     }
     printf("无组合估计二阶矩:%.2lf\n",secmom_estima/N);

     /***********真实二阶矩*************/
     for(j=;j<count_tmp;j++)
     {
         //printf("%d\t%d\n",attr[j].element,attr[j].count);
         secmom+=attr[j].count*attr[j].count;
     }
     printf("独立数%d\n",count_tmp);
     printf("真实二阶矩为:%d\n",secmom);

     system("pause");
     return ;
 }