Java-Arraylist的.get和.remove的大O？

我假设ArrayList.get和ArrayList.remove都有一个O（n）的大O，对吗

因此，我下面的代码的时间复杂度为O（n^2），对吗？

 import java.util.ArrayList;

public class TestingJava {

    public ArrayList<Integer> plusOne(ArrayList<Integer> a) {
        // If vector has [1, 2, 3]
        // returned vector should be [1, 2, 4]
        // 123 + 1 = 124
        int total = 0;

        // O(n)
        for(Integer i: a){
            total = 10*total + i;
        }

        total += 1;
        int last_dig = total%10;
        a.set((a.size()-1), last_dig);

        // O(n**2)
        while (a.get(0) == 0){
            a.remove(0);
        }

        return a;

    }

    public static void main(String[] args) {
        ArrayList<Integer> a1 = new ArrayList<>();
        a1.add(0);
        a1.add(1);
        a1.add(2);
        a1.add(3);
        TestingJava c = new TestingJava();
        System.out.println(c.plusOne(a1));
        // Should output [1, 2, 4]. Should NOT output [0, 1, 2, 4]
    }
}

import java.util.ArrayList；
公共类测试Java{
公共ArrayList plusOne（ArrayList a）{
//如果向量有[1,2,3]
//返回的向量应该是[1,2,4]
// 123 + 1 = 124
int-total=0；
//O（n）
for（整数i:a）{
总计=10*总计+i；
}
总数+=1；
int last_dig=总计%10；
a、 设置（（a.size（）-1），最后一次挖掘）；
//O（n**2）
而（a.get（0）=0）{
a、 移除（0）；
}
返回a；
}
公共静态void main（字符串[]args）{
ArrayList a1=新的ArrayList（）；
a1.加入（0）；
a1.加入第（1）款；
a1.加入第（2）款；
a1.加入第（3）款；
TestingJava c=新的TestingJava（）；
系统输出println（c.plusOne（a1））；
//应输出[1,2,4]。不应输出[0,1,2,4]
}
}

---

免责声明：我只是为了面试而练习，这不是家庭作业或作业。如果你想练习这个问题，你可以先去

，我总是喜欢编程到

列表

界面；而不是直接

ArrayList

，在公共方法签名中更是如此。您可以从右侧开始，而不是从左侧迭代值。这是

O（n）

，但包含嵌套循环。进位，直到当前值不是

9

，一旦它是从右边复制的，直到你点击

0

和，然后

返回

。像

public static List<Integer> plusOne(List<Integer> a) {
    List<Integer> b = new ArrayList<>();
    for (int i = a.size() - 1; i >= 0; i--) {
        int val = a.get(i);
        if (val == 9) {
            b.add(0, 0);
            continue;
        }
        b.add(0, val + 1);
        while (i > 0 && (val = a.get(--i)) != 0) {
            b.add(0, val);
        }
        return b;
    }
    b.add(0, 1);
    return b;
}

公共静态列表plusOne（列表a）{
列表b=新的ArrayList（）；
对于（int i=a.size（）-1；i>=0；i--）{
int val=a.get（i）；
如果（val==9）{
b、 加（0,0）；
继续；
}
b、 加（0，val+1）；
而（i>0&（val=a.get（-i））！=0）{
b、 加（0，val）；
}
返回b；
}
b、 添加（0,1）；
返回b；
}

为什么

get（）

是O（n）

ArrayList

由数组支持。@LoganKulinski没有搜索ArrayList，因此将依赖ArrayList的长度？我是java新手，所以我正在尝试找出这些方法的时间复杂性。@Theo

get（）

不搜索

ArrayList

。它所做的只是转到特定索引处的元素，就像使用方括号的数组一样。

get

以恒定时间运行（也称为O（1））。JavaDocs对此是明确的。他们没有明确说明删除，但确实是O（N），也就是说，这是O（N^2）。原因不是因为

get（0）

本身；相反，

while

循环可能会运行N次（如果列表中的所有元素都==0），并且对于其中的每一个元素，您都会执行O（N）remove。