相关疑难解决方法(0)

我正在寻找一个可以计算函数Big 0的java算法分析工具.理想我想将其作为构建过程的一部分,与我的其他代码度量工具一起使用.即使在谷歌搜索后,我也无法找到任何商业工具的开源.任何建议都会受到欢迎

谢谢

我已经阅读了很多关于isEmpty()和size()0 之间的区别的文章,对于检查是否collection为空或者没有,并且发现isEmpty()有性能size()但我无法理解为什么性能isEmpty()良好即使内部isEmpty()只有size == 0？

我的问题是:

1. 任何人都可以轻松解释哪种情况isEmpty()更快,以及何时使用isEmpty()和size()功能检查是否collection是empty？

2. 任何人都可以使用代码或其他方式(图表,图表等)解释这一点,以便任何初学者都能轻松理解吗？

可能重复:
Big O的简单英文解释

我一直在努力计算我编写的算法的Big-O时间和空间复杂度.

任何人都可以指出一个很好的资源来研究算法的空间复杂性.

编辑:我在发布之前搜索过教程.遗憾的是,所有教程都侧重于运行时复杂性,并且几乎没有写太多关于空间复杂性的内容.

我试图找出这个伪代码给定算法的时间复杂度:

sum = 0;
for (i = 1; i <= n; i++)
    for (j = 1; j <= n / 6; j++)
        sum = sum + 1;

我知道第一条线路运行

n次

但我不确定第二行.

我已经编写了递归和迭代二进制搜索的算法：

递归

AlgorithmBinSrch(a, i,l,x)
// Given an array a[i :l] of elementsin nondecreasing
// order,1<i <=l,determinewhetherx is present,and
// if so,return j suchthat x = a[j];elsereturn 0.
{
    if (l =i) // If Small(P) {
        if(x=a[i]) 
            return i;
        else 
            return 0;
    } else { // ReduceP into a smallersubproblem.
        mid:=[(i+l)/2]; 
        if (x = a[mid]) 
            return mid;
        else if (x <a[mid]) 
            returnBinSrch(a,i,mid-1,x);
        else
            returnBinSrch(a,mid1+,l,x);
    } 
}

迭代

// Given an array a[1:n] of elementsin nondecreasing
// order,n >=0,determine whether x is …

我已经阅读了这么多资源,仍然坚持理解时间复杂性.我读过的资源基于各种公式,我理解这O(n)用于表达时间复杂度,但我不知道如何.请有人以一种可以理解的明确方式向我解释这个原则.

我编写了一个代码段来确定图中最长的路径.以下是代码.但由于中间的递归方法,我不知道如何在其中获得计算复杂性.由于找到最长的路径是NP完全问题,我认为它类似于O(n!)或者O(2^n),但我怎么能真正确定它呢？

public static int longestPath(int A) {
    int k;
    int dist2=0;
    int max=0;

    visited[A] = true;

    for (k = 1; k <= V; ++k) {
        if(!visited[k]){
            dist2= length[A][k]+longestPath(k);
            if(dist2>max){
                max=dist2;
            }
        }
    }
    visited[A]=false;
    return(max);
}

我正在为算法中的班级学习,并一直关注QuickSort.我理解算法及其工作原理,但不知道如何在一天结束时获得它所做的比较次数或登录实际意味着什么.

我理解基础知识,达到以下程度:

x=logb(Y) then
b^x = Y

但这在算法性能方面意味着什么呢？这是你需要做的比较的数量,我明白......尽管如此,整个想法似乎是如此难以理解.例如,对于QuickSort,每个级别的K调用都涉及2^k每个涉及长度子列表的调用n/2^K.

所以,总结找到比较的数量:

log n
? 2^k. 2(n/2^k) = 2n(1+logn)
k=0

为什么我们总结记录n？2n(1 + logn)来自哪里？很抱歉我的描述含糊不清,我很困惑.

我正在尝试以毫秒为单位计时我的函数的执行时间。我使用performance.now（）来做到这一点。我可以在第一次运行时获得时间，但是在第二次，第三次运行时，我得到0毫秒。这是一个例子：

function someFunction (){
    var t0 = performance.now();
    //Function calculations
    var t1 = performance.now();
    Console.log(t1 - t0);
}

我启动功能onclick。当我第一次启动页面时，它可以工作。在第二次单击时它将停止工作。t0和t1得到相同的值，当我减去它们时，我得到的时间为0。反正周围有吗？我不一定需要使用performance.now（）。我只想以毫秒为单位测量时间。

谢谢。

更新 我认为这与速度有关。例如：

function someFunction (){
    var t0 = performance.now();
    //Function calculations
    var t1 = performance.now();
    Console.log(t1 - t0);
}

符合我的预期，但是使用循环for (i = 0; i < 1000; i++)却没有。

感谢您指出正确方向的指示。

我是Java的新手,我的问题是关于大O的复杂性.

对于a),它显然O(n^2)是一个嵌套循环.

for ( int i = 0; i < n; i++)
    for ( int j=0; j < n; j++ )

但是,对于b),最后使用sum ++操作,以及嵌套循环中的复杂性,是否会改变其Big-O复杂性？

int sum = 0;
for ( int i = 1; i <= n; i++)
    for ( int j = n; j > 0; j /= 2)
        sum++;