精华内容
下载资源
问答
  • 在复杂的容限网络中计算频度、持久度和可用参数是非常困难的。通过列举出所有可行网络拓扑的方法来计算出给定各边容量的网络的这些参数。这种方法既可获得这些参数的表达式,也可计算出其精确值。
  • 缺点在于需要将程序跑一边,如果越到耗时程序的时候效率不高,而且要求计算机的硬件软件的环境一致,保证运行环境相同才有可信。 事后统计法: 通过分析某一个程序算法具体的时间复杂度来度量一个算法的优劣。 ...

    度量一个程序算法执行时间的两种方法

    • 事后统计法: 直白就是把程序跑一边,统计程序从开始到结束花费的时间。缺点在于需要将程序跑一边,如果越到耗时程序的时候效率不高,而且要求计算机的硬件软件的环境一致,保证运行环境相同才有可信度。
    • 事后统计法: 通过分析某一个程序算法具体的时间复杂度来度量一个算法的优劣。

    时间频度

    一个算法花费的时间与算法中语句执行数成正比。哪个算法执行的次数越多,则它花费的时间就多。一个算法中语句执行的次数成为时间频度,记做T(n)。

    例如:计算1-100的总和

    // 方式1
    int total = 0;
    int num = 100;
    for(int i=0;i<=num;i++){
        total = i+total;
    }
    
    // 方式2
    int num = 100;
    int total = (1+num)*num/2
    

    此时方式1中的时间频度为100+1次 记为 T(n)=n+1 n=100因为循环了100次 +1是因为有一个判断

    方式2的时间频度为1 因为只有一条语句 记为 T(n)=1

    时间复杂度

    时间复杂度是度量算法花费时间,算法中的基本操作语句和重复执行次数是问题规模N的某个函数,用T(n)表示,若有有个辅助函数f(n),当n趋近无穷大时,T(n)/f(n)的极限值为一个不等于零的常数,则称f(n)和T(n)是同数量级的函数记为 T(n)=O(f(n)),简称O(n),为一个算法的渐进时间复杂度,简称时间复杂度。

    时间复杂的计算方法

    1. 分析出算法的运行时间频度
    2. 用常数1代替算法中所有加法常数 如 T(n)=2n²+5n+5 ==> T(n)=2²+5n+1
    3. 只保留最高阶项 如 T(n)=2n²+5n+5 ==> T(n)=2n²
    4. 取出最高阶的系数 T(n)=2n²+5n+5 ==> T(n)=n² 则最终时间复杂度为 T(n)=n²记为O(n²)

    常见时间复杂度

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8OhRClVG-1594869812967)(C:\Users\denglw\AppData\Roaming\Typora\typora-user-images\image-20200715103543819.png)]

    1. 常数阶 O(1)

      无论代码执行了多少行,只要没有循环等复杂结构时间复杂度为O(1)

      int i = 1;
      int j = 2;
      i++;
      j++;
      int total = i+j;
      

      ​ 上述代码时间消耗不会随着变量的增长而增长,即i=1或者i=10000都是一样的,无论有多少行,一行或者及万行都可以用O(1)来表示时间复杂度。

    2. 对数阶 O(log2n)

      int i = 1;
      int n = 1024;
      while(i < n){
          i = i*2;
      }
      // 或者
      for(int i=0; i<n; i*=2){
          System.out.println(i);
      }
      

      上述代码中while循环或者for 循环 的执行次数为 以2为底数1024的对数 log2N,当N增大时,时间频度成对数上升,类似于一根长16M的绳子,每次割一半,割到一米需要几次的问题,第一次为8M,第二次为4M,第三次为2M,第四次为1M,则时间频度具体值为4,为log16。则可以记做O(logn)。上述如果把i=i2改成 i=i3 则变成了 log3N 以3为底N的对数了.

    3. 线性阶 O(n)

      int n =100;
      for(int i=0; i<n; i++){
          System.out.println(i);
      }
      

      则表示for循环中需要执行多少次,上述代码是一个线性的,随着N的增加,执行次数就增加N次。如n=100 则执行100次 n=200则执行200次,在坐标轴上是一条直线上升的趋势。记为O(n)

    4. 线性对数阶 O(nlog2n)

      int n =100;
      int m = 1024;
      for(int i=0; i<n; i++){
             while(i < m){
              i = i*2;
          }
      }
      

      简单的理解就是一个对数阶的代码循环N遍则变成了线性对数阶,上述代码中 while循环是一个对数阶 为log1024 记做logN for循环是一个线性阶 n n=100 则他们一起的时间复杂度为O(nlogN)

    5. 平方阶 O(n^2)

      int n = 100;
      int m = 100;
      for (i=0; i < n ; i++){
          for(i=0; i < m ;i++){
              System.out.println(i);
          }
      }
      

      平方阶就是循环套循环,2层循环就是一个n2的平方阶,时间复杂度就是O(n2)

    6. 立方阶 O(n^3)

      立方阶则是3层循环嵌套

    7. k 次方阶 O(n^k)

      k层循环嵌套

    8. 指数阶 O(2^n)

      long function1(int n) {    
          if (n <= 1) {        
              return 1;
          } else {        
              return function1(n - 1) + function1(n - 2);
          }
      }
      

      类似上述从出现递归的时候,T(0) = T(1) = 1,同时 T(n) = T(n - 1) + T(n - 2) + 1,这里的 1 是其中的加法算一次执行。显然 T(n) = T(n - 1) + T(n - 2) 是一个斐波那契数列,通过归纳证明法可以证明,当 n >= 1 时 T(n) < (5/3)^n,同时当 n > 4 时 T(n) >= (3/2)^n。所以该方法的时间复杂度可以表示为 O((5/3)^n),简化后为 O(2^n)。

    上述时间复杂度从上到下一次递增,在程序设计过程中需要避免指数阶的时间复杂度。

    空间复杂度

    指程序算法运行过程中对临时占用存储空间如内存的大小,不过从用户体验来是说,用户并不关系后台占用的具体多少内存,只关心多久能给我反馈即执行的速度,所以出现了很多缓存产品,本质上就是用空间换时间的过程。

    展开全文
  • 一、resample ...把高频度的数据变为低频度叫做降采样(downsampling),把低频度变为高频叫做升采样(upsampling) resample参数如下: resample(rule, how=None, axis=0, fill_method=None,...

    一、resample

    • resample()进行重采样。

    • 重采样(Resampling)指的是把时间序列的频度变为另一个频度的过程。把高频度的数据变为低频度叫做降采样(downsampling),把低频度变为高频度叫做升采样(upsampling)

    resample参数如下:

    resample(rule, how=None, axis=0, fill_method=None, closed=None, label=None, convention='start',kind=None, loffset=None, limit=None, base=0)

    降采样

    考虑因素:

    • 各区间哪边是闭合的(参数:closed)

    • 如何标记各聚合面元,用区间的开头还是末尾(参数:label)

    freq取值如下:

                               

    In [232]: ts_index = pd.date_range('2018-08-03',periods =12,freq = 'T')
    
    In [233]: ts = pd.Series(np.arange(12),index = ts_index)
    
    In [234]: ts
    Out[234]:
    2018-08-03 00:00:00     0
    2018-08-03 00:01:00     1
    2018-08-03 00:02:00     2
    2018-08-03 00:03:00     3
    2018-08-03 00:04:00     4
    2018-08-03 00:05:00     5
    2018-08-03 00:06:00     6
    2018-08-03 00:07:00     7
    2018-08-03 00:08:00     8
    2018-08-03 00:09:00     9
    2018-08-03 00:10:00    10
    2018-08-03 00:11:00    11
    Freq: T, dtype: int32
    

    默认使用左标签(label=‘left’),左闭合(closed='left’)

    此时第一个区间为:2018-08-03 00:00:00~2018-08-03 00:04:59,故sum为10,label为:2018-08-03 00:00:00

    In [235]: ts.resample('5min').sum()
    Out[235]:
    2018-08-03 00:00:00    10
    2018-08-03 00:05:00    35
    2018-08-03 00:10:00    21
    Freq: 5T, dtype: int32
    

    可以指定为右闭合(closed='right’),默认使用左标签(label=‘left’)

    此时第一个区间为:2018-08-02 23:55:01~2018-08-03 00:00:00,故sum为0,label为:2018-08-02 23:55:00

    In [236]: ts.resample('5min',closed='right').sum()
    Out[236]:
    2018-08-02 23:55:00     0
    2018-08-03 00:00:00    15
    2018-08-03 00:05:00    40
    2018-08-03 00:10:00    11
    Freq: 5T, dtype: int32
    

    可以指定为右闭合(closed='right’),右标签(label=‘right’)

    此时第一个区间为:2018-08-02 23:55:01~2018-08-03 00:00:00,故sum为0,label为:2018-08-03 00:00:00

    In [237]: ts.resample('5min',closed='right',label='right').sum()
    Out[237]:
    2018-08-03 00:00:00     0
    2018-08-03 00:05:00    15
    2018-08-03 00:10:00    40
    2018-08-03 00:15:00    11
    Freq: 5T, dtype: int32
    

    升采样

    考虑因素:

    • 没有聚合,但是需要填充
    In [244]: frame = pd.DataFrame(np.random.randn(2, 4),
         ...:                      index=pd.date_range('1/1/2000', periods=2,
         ...:                                          freq='W-WED'),  # freq='W-WED'表示每周三
         ...:                      columns=['Colorado', 'Texas', 'New York', 'Ohio'])
    
    In [245]: frame
    Out[245]:
                Colorado     Texas  New York      Ohio
    2000-01-05  1.201713  0.029819 -1.366082 -1.325252
    2000-01-12 -0.711291 -1.070133  1.469272  0.809806
    

    当我们对这个数据进行聚合的的时候,每个组只有一个值,以及gap(间隔)之间的缺失值。在不使用任何聚合函数的情况下,我们使用asfreq方法将其转换为高频度:

    In [246]: df_daily = frame.resample('D').asfreq()
    
    In [247]: df_daily
    Out[247]:
                Colorado     Texas  New York      Ohio
    2000-01-05  1.201713  0.029819 -1.366082 -1.325252
    2000-01-06       NaN       NaN       NaN       NaN
    2000-01-07       NaN       NaN       NaN       NaN
    2000-01-08       NaN       NaN       NaN       NaN
    2000-01-09       NaN       NaN       NaN       NaN
    2000-01-10       NaN       NaN       NaN       NaN
    2000-01-11       NaN       NaN       NaN       NaN
    2000-01-12 -0.711291 -1.070133  1.469272  0.809806
    

    使用ffill()进行前向填充

    In [248]: frame.resample('D').ffill()
    Out[248]:
                Colorado     Texas  New York      Ohio
    2000-01-05  1.201713  0.029819 -1.366082 -1.325252
    2000-01-06  1.201713  0.029819 -1.366082 -1.325252
    2000-01-07  1.201713  0.029819 -1.366082 -1.325252
    2000-01-08  1.201713  0.029819 -1.366082 -1.325252
    2000-01-09  1.201713  0.029819 -1.366082 -1.325252
    2000-01-10  1.201713  0.029819 -1.366082 -1.325252
    2000-01-11  1.201713  0.029819 -1.366082 -1.325252
    2000-01-12 -0.711291 -1.070133  1.469272  0.809806
    
    In [249]: frame.resample('D').ffill(limit=2)
    Out[249]:
                Colorado     Texas  New York      Ohio
    2000-01-05  1.201713  0.029819 -1.366082 -1.325252
    2000-01-06  1.201713  0.029819 -1.366082 -1.325252
    2000-01-07  1.201713  0.029819 -1.366082 -1.325252
    2000-01-08       NaN       NaN       NaN       NaN
    2000-01-09       NaN       NaN       NaN       NaN
    2000-01-10       NaN       NaN       NaN       NaN
    2000-01-11       NaN       NaN       NaN       NaN
    2000-01-12 -0.711291 -1.070133  1.469272  0.809806
    

    新的日期索引没必要跟旧的重叠

    In [250]: frame.resample('W-THU').ffill()
    Out[250]:
                Colorado     Texas  New York      Ohio
    2000-01-06  1.201713  0.029819 -1.366082 -1.325252
    2000-01-13 -0.711291 -1.070133  1.469272  0.809806
    

    分组重采样

    In [279]: times = pd.date_range('2018-08-3 00:00', freq='1min', periods=10)
    
    In [280]: df2 = pd.DataFrame({'time': times.repeat(3),
         ...:                     'key': np.tile(['a', 'b', 'c'], 10),
         ...:                     'value': np.arange(30)})
    
    In [281]: df2[:5]
    Out[281]:
       key                time  value
    0    a 2018-08-03 00:00:00      0
    1    b 2018-08-03 00:00:00      1
    2    c 2018-08-03 00:00:00      2
    3    a 2018-08-03 00:01:00      3
    4    b 2018-08-03 00:01:00      4
    
    In [282]: df2.groupby(['key',pd.Grouper(key='time',freq='5min')]).sum()
    Out[282]:
                             value
    key time
    a   2018-08-03 00:00:00     30
        2018-08-03 00:05:00    105
    b   2018-08-03 00:00:00     35
        2018-08-03 00:05:00    110
    c   2018-08-03 00:00:00     40
        2018-08-03 00:05:00    115
    

    asfreq()

    • asfreq()进行频度转换。
    • 当您要将DatetimeIndex更改为具有不同的频率同时在当前索引处保留相同的值时,可以使用asfreq.
    • asfreq() : 采样时间点的value
    • resample() : 采样时间段内value

     

                           

    ts如上图:

    ts.asfreq('D').sum()
    -1.0655834142614131

     

    ts.resample('D').sum()

     

    -2.494026

     

    • 缺失值的填充方式.

    • method : {‘backfill’, ‘bfill’, ‘pad’, ‘ffill’, None}
    >>> index = pd.date_range('1/1/2000', periods=4, freq='T')
    >>> series = pd.Series([0.0, None, 2.0, 3.0], index=index)
    >>> df = pd.DataFrame({'s':series})
    >>> df
                           s
    2000-01-01 00:00:00    0.0
    2000-01-01 00:01:00    NaN
    2000-01-01 00:02:00    2.0
    2000-01-01 00:03:00    3.0
    

    将频度转换为30s

    >>> df.asfreq(freq='30S')
                           s
    2000-01-01 00:00:00    0.0
    2000-01-01 00:00:30    NaN
    2000-01-01 00:01:00    NaN
    2000-01-01 00:01:30    NaN
    2000-01-01 00:02:00    2.0
    2000-01-01 00:02:30    NaN
    2000-01-01 00:03:00    3.0
    

    将频度转换为2min,不会进行重采样(与resample的不同之处)

    >>> df.asfreq(freq='2min')
                           s
    2000-01-01 00:00:00    0.0
    2000-01-01 00:02:00    2.0

    使用bfill()进行后向填充

    >>> df.asfreq(freq='30S').bfill()
                           s
    2000-01-01 00:00:00    0.0
    2000-01-01 00:00:30    NaN
    2000-01-01 00:01:00    NaN
    2000-01-01 00:01:30    2.0
    2000-01-01 00:02:00    2.0
    2000-01-01 00:02:30    3.0
    2000-01-01 00:03:00    3.0
    
    补充:day3Ts.resample('D').interpolate('linear') # 线性插值

    --------------------------------------------------------------------------------------------------------- 

                                                                                                    原文:https://blog.csdn.net/starter_____/article/details/81437626 

    展开全文
  • 时间频度介绍

    2021-06-07 17:09:12
    **时间频度:**一个算法花费的时间与算法中语句执行次数成正比。 对于时间频度来说,常数项可以忽略,低次项也可以忽略, 时间复杂度:

    在这里插入图片描述
    **时间频度:**一个算法花费的时间与算法中语句执行次数成正比。
    对于时间频度来说,常数项可以忽略,低次项也可以忽略,

    展开全文
  • 把高频度的数据变为低频度叫做降采样(downsampling),把低频度变为高频叫做增采样(upsampling)。 降采样 考虑因素: 各区间哪边是闭合的(参数:closed) 如何标记各聚合面元,用区间的开头还是末尾(参数:...
  • 题目:设头指针为L的带有表头结点的非循环双向循环链表,其每个结点中除有pred(前驱指针),data(数据)next(后继指针)域外,还有一个访问频度域freq。 在链表被启用前,其值均初始化为0。每当在链表中进行一...

    题目:设头指针为L的带有表头结点的非循环双向循环链表,其每个结点中除有pred(前驱指针),data(数据)和next(后继指针)域外,还有一个访问频度域freq。
    在链表被启用前,其值均初始化为0。每当在链表中进行一次Locate(L,x),运算时,令元素值为x的结点中freq域的值+1,并使此链表中结点保持按访问频度非增(递减)的顺序排列,同时最近访问的结点排在频度相同的结点前面,以便使频繁访问的结点总是靠近表头。

    试编写符合上述要求的Locate(L,x)运算的算法,该运算为函数过程,返回找到结点的地址,类型为指针型。

    关键字:带头结点双链表+统计访问频度+按度&访问先后排序

    思路
    关注:双链表的查找、删除和插入算法
    保持按访问频度非增(递减)的顺序排列

    1.首先在双向链表中查找数据值为X的结点,
    2.查到后,将结点从链表中摘下,
    3.然后再顺着结点的前驱链(双链表要灵活运用前驱链)查找该结点的插入位置
    (题目要求:频度递减,且排在同频度的第一个,即向前找到第一个比它频度大的结点,插入位置为该结点之后),
    4.并插入到该位置:注意步骤的顺序。指针的调配
    需要变量:L,x
    当前值为x的元素的工作指针p,pre为前驱指针(负责插入功能的指针)

    
    DLinkList Locate(DLinkList &L,ElemType X){//本算法先查找数据X(用户输入x默认已经完成了),查找成功时结点的访问频度+1
    //最后将该结点按频度递减插入链表中适当位置,同频度最近访问的在前面
       DNode *p=L-next,*pre;//p为工作指针,pre为前驱指针(负责查找插入位置)
       while(p&&p->data!=x)//当遍历没有结束并且没有查找到值为X的元素时
          p=p->next;//p向下遍历
       if(!p){//如果遍历结束也没找到值为x的元素
         printf("不存在值为X的结点\n")
         exit(0);
       }
       else{//如果找到了值为x的元素
          p->freq++; //当前元素的频度+1
          if(p->next!=NULL) //如果当前元素不是最后一个元素,即“后继还有人”
            p->next->pred=p->pred;  //那么将当前元素的后继元素的前驱链接到当前元素的前驱元素
          p->pred->next=p->next; //将当前元素的前驱元素的后继链接给当前元素的后继元素,以上两步完成了将当前元素摘出的功能
          pre=p->pred; //开始寻找插入位置
          while(pre!=L&&pre->freq<=p->freq) //当插入位置没有找到
               pre=pre->pred; //前驱指针继续向前寻找,直到找到(本题中此条件一定可以找到的)
          p->next=pre->next; //开始插入当前元素
          pre->next->pred=p; //
          p->pred=pre; //
          pre->next=p; //
          }
        return p;
       }
         
       }
    
    
    展开全文
  • 利用2004~2010年北太平洋鱿钓船队生产数据海洋环境数据,以海表温度(SST)1℃、海面高度(SSH)为1cm、叶绿素a浓度(CHL-a)为0.1mg/m3的间距,分析作业产量、CPUE与SST、SSH、CHL-a的关系,得到柔鱼渔场适宜...
  • HTML CSS 时出现频度较高的160 个单词 A absolute 绝对的 active 活动的,激活的,标记的一个伪类 align 对齐 alpha 透明,半透明anchor 锚记标记是这个单词的缩写 arrow
  • 该方法借鉴社会学信任模型,通过 Web服务节点间的协作频度对Web服务进行聚类,提出个体信任、群体信任度和综合信任的概念,给出了一个Web服务信任评估模型.还设计了一种基于全局信任管理本地信任管理的 Web...
  • 为进一步提高文语转换系统中韵律结构预测的准确,提出了一个基于概率频度的统计模型的方法,预测韵律词韵律短语边界两级韵律结构。该方法提取与韵律词韵律短语边界有关的语言学特征(词性、语法词、长度位置...
  • 扫描一个C源程序,用Hash表存储该程序中出现的关键字,并统计该程序中的关键字出现的。用线性探测法解决Hash冲突。设Hash函数为:Hash(Key)=[(Key的首字母序号)*100+(Key的尾字母序号)] Mod 41。关键字39个,参考...
  • Spark MLlib 1.6 -- 频度模式挖掘

    千次阅读 2016-03-22 13:05:34
    挖掘频繁关联物品,频繁关联物品集,频繁关联子序列,或其它子结构是分析海量数据的第一步,并且连续几年作为数据挖掘主要研究方向。...提供并行FP-growth算法,这个算法经常用于挖掘频度物品集。   8.1 FP-grow
  • 频度与贝叶斯――白猫黑猫?

    千次阅读 2013-08-07 17:09:03
    以下所记,只是自己在学习贝叶斯期间的灵光闪现的心得与感受,混杂了频度统计与贝叶斯统计,或对或错,故放亮你的眼睛,呵呵。侧重于粗略的线条,具体细节未述。 主要从下面几个方面,大概的介绍...
  • 问题描述:双向链表L(结点中含有fre频度),每次访问元素后,元素按访问频度递减次序排列 说明: 这个问题题非常向操作系统中应用的一些算法了,比如说涉及到内存、磁盘中数据的访问,换出等。这个链表中保存的是...
  • /** * @author:(LiberHome) * @date:Created in 2019/3/1 19:16 * @description: .../*请在5*5的矩阵中找出频度最高的元素*/ public class page0801 { public static void main(String[] args) { ...
  • /*带头结点的非循环双向链表,其中每个结点中多一个freq频度域。每次Locate(L,x)访问过值为x的函数后,freq+1,并使此链表中结点保持按访问频度递减的顺序排列, 同时最近访问的结点排在频度相同的结点前面,以便使...
  • as(四级考试频度很大的几个用法)

    千次阅读 2018-03-14 22:21:15
    不管他用大劲也举不起那块石头。There was not a soul to be found in the house,search as they would.不管他们怎么寻找,房子里也找不到一个人。 2.作关系代词,使用下面句型:1)"such…as"(as在此接近于...
  • 如何统计一个列表元素的频度 两个需求: 1,统计一个随机序列[1,2,3,4,5,6...]中的出现次数前三的元素及其次数 2,统计一片英文文章中出现次数前10 的单词 两种方法: 1,普通的for循环,结合前边 python基础一...
  • Python程序员面试算法宝典---解题总结: 第9章 大数据 9.9 如何按照query的频度排序 题目: 有10个文件,每个文件1GB,每个文件的每一行存放的都是用户的query,每个文件的 query都可能重复。要求按照query的频度排序...
  • 关键词:线性化 共模噪声 结点补偿 温度漂移 PWM模式1、工业中常用温度传感器的分类 温度是测量频度最高的物理参数,并且可采用各种各样的传感器来进行测量。所有这些传感器均通过检测某种物理特性的变化来推断...
  • 温度传感器的分类及比较

    千次阅读 2017-12-21 16:37:47
    在飞速发展的新时代,工业中温度传感器变得越来越重要,在工业生产中,温度是测量频度最高的物理参数,  并且可采用各种各样的传感器来进行测量。所有这些传感器均通过检测某种物理特性的变化来推断温度。  可见...
  • 对于仅处理结构化数据(比如日期,数值字符枚举值)的数据库,它们只需要检查一份文档(在关系数据库中是一行)是否匹配查询即可。 尽管布尔类型的YES|NO匹配也是全文搜索的一个必要组成,它们本身是不够的。我们还...
  • Elasticsearch: 权威指南 » 深入搜索 » 控制相关 » 相关评分背后的理论 学习 ##词频/逆向文档频率(TF/IDF) ##当匹配到一组文档后,需要根据相关排序这些文档,不是所有的文档都包含所有词,有些词比其他...
  • 3:业务人员参与到迭代中,掌握市场研发两边情况,调整变更优先级,积极协调研发、市场用户的业务关系,用户满意较高 3+:持续变更管理,将变更变成常态,成为可规划可管理的流畅过程。用户需求得到...
  • Android监测获取当前温度变化,使用 SensorManager.SENSOR_TEMPERATURE来监测当前温度,在这个实例中调用了很方法,SensorManager mySensorManager;//SensorManager对象引用,声明SensorManagerSimulator对象,调试...
  • 自由+凝固+统计的新词发现

    千次阅读 2019-06-09 21:29:11
    例如怕上火,下一句是喝王老吉,好像怕上火下一句很少接其他的词,那就是它的自由不高,而一个真正的词必定可以词配合,所以’怕’+‘上火’就不能构成一个新词。实际上我们统计’怕上火’的左右邻词邻词...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,291
精华内容 6,116
关键字:

多度和频度