Algorithm 降低排序算法的big-O复杂度

几周前，我认识了big-O，并试图解决它，但尽管有很多关于计算时间复杂度的资料，我似乎无法找到如何使算法更有效

我一直在练习Codibility的演示挑战：

编写一个函数，给定一个由N个整数组成的数组a，该函数返回在a中不出现的最小>正整数（大于0）。例如，给定a=[1,3,6,4,1,2]，该函数应返回5。
给定的数组可以包含-100万到100万之间的整数

我从蛮力算法开始：

public int solution(int[] A)
        {
            for ( int number = 1; number < 1000000; number ++)
            {
                if (doesContain(A, number)){}
                else return i;
            }
            return 0;
        }

public int解决方案（int[]A）
{
对于（整数=1；数字<1000000；数字++）
{
if（doesContain（A，number））{}
否则我会回来；
}
返回0；
}

它通过了所有正确性测试，但性能得分较低，因为运行时间远远超过了限制，时间复杂度为O（N**2）

然后，我尝试将数组放入arraylist，这样可以减少大O，因为每个对象只“接触”一次，并且我可以使用.Contains，它比迭代更有效（不确定这是不是真的；我只是记得在某处读过它）

public int解决方案（int[]A）
{
ArrayList myArr=新的ArrayList（）；
对于（int i=0；i这是一个典型的面试问题。忘记排序；这是一个检测问题，
n
元素上的O（n+m），最大值
m
（作为常量给出）

我的想法是：你可以对数组进行降序排序（可以是O（n log n）），然后迭代直到
array[i+1]
@Marvin不完全，这将为
[6,8]
返回7，当它应该返回1时。如果让k为允许的最大整数（问题中的1000000），我将放弃任何值
，您也可以在O（max（k，n））中求解它，方法是创建一个数组
flag[]
，其中k+1位初始化为除
flag[0]
之外的所有false。迭代数组并设置
flag[array[i]]
if
array[i]>0
。然后找到第一个
i
，这样
flag[i]
未设置。为了获得最快的结果，如果kpublic int solution(int[] A)
    {
        ArrayList myArr = new ArrayList();
        for (int i=0; i<A.Length; i++)
        {
            myArr.Add(A[i]);
        }
        for ( int i = 1; i < 1000000; i++)
        {
            if (myArr.Contains(i)){}
            else return i;
        }
        return 0;
    }

boolean found[1000000] = False  /// set all elements to false

for i in A    // check all items in the input array
    if i > 0
        found[i] = True

for i in (0, 1000000)
    if not found[i]
        print "Smallest missing number is", i