Question

我正在尝试计算这三种算法的Big-O时间复杂度，但似乎我对这个主题缺乏了解。
第一：

private void firstAlgorithm(int size) {
int[] array = new int[size];
int i=0; int flag=0;
while(i<size) {
    int num=(int)(Math.random()*(size));
    if (num==0 && flag==0) {
        flag=1;
        array[i]=0;
        i++;
    } else if(num==0 && flag==1) {
        continue;
    } else if(!checkVal(num, array)) {
        array[i]=num;
        i++;
    }
}
}
private static boolean checkVal(int val, int[] arr) {
    int i = 0;
    for (int num:arr) {
        if (num==val) {
            return true;
        }
    }
    return false;
}

第二

private void secondAlgorithm(int size) {
    int i = 0;
    int[] array = new int[size];
    boolean[] booleanArray = new boolean[size];

    while (i < array.length) {
        int num = (int) (Math.random() * array.length);
        if (!booleanArray[num]) {
            booleanArray[num] = true;
            array[i] = num;
            i++;
        }
    }
}

第三

private void thirdAlgorithm(int size) {
    int[] array = new int[size];

    for (int i = 0; i < array.length; i++) {
        int num = (int) (Math.random() * (i - 1));
        if (i > 0) {
            array = swap(array, i, num);
        }

    }
}
private static int[] swap(int[] arr, int a, int b) {
    int i = arr[a];
    arr[a] = arr[b];
    arr[b] = i;
    return arr;
}

如果你能解释一下你的结果会很好。在我看来，1 - O（n ^ 2）因为两个循环，第二个不知道，第3个O（n）谢谢你

Answer 1

我假设在您生成随机数的所有算法中，您打算获取生成的数字的剩余部分，而不是将其与另一个值相乘（第一个算法的示例：Math.random() % size）。如果不是这种情况，那么上述任何一种算法都很有可能在合理的时间内完成。

第一个算法生成并填充size个整数数组。规则是数组必须只包含一个0值且只包含不同的值。检查数组是否已包含新生成的值是在O(m)中完成的，其中m是已插入数组中的元素数。您可以对要插入的每个size元素执行此检查，并且m可以与size一样大，因此运行时的上限为O(size^2)。< / p>

第二种算法也使用随机数生成并填充数组，但这次数字不必是不同的，因此不需要在每次迭代时运行额外的O(m)检查。总体复杂性由数组的大小给出：O(size)。

第三种算法使用随机数生成并填充数组，并且在每次迭代时，它根据给定的索引交换一些元素，这是一个恒定的时间操作。此外，将数组的引用重新分配给自身是一个恒定时间操作（O(1)）。结果是运行时间受O(size)限制。

计算3个随机排列算法的BIg-O

1 个答案: