complejidad de tiempo para iterar a través de una lista de matriz

Todas las otras respuestas están mal aquí.

  1. Su primer ciclo para iterar la itemslista: la complejidad esO(n)
  2. Inserte cada elemento al final de la lista lessItems: en la matriz normal será O(n)como otros dijeron. Pero Java implementa para ArrayListusar una matriz amortizada . Esto significa que al insertar al final de la matriz, el algoritmo solo cuesta Amortized O(1). O puedes decirO(1)

Así complejidad de su código es: O(n) * amortized O(1). En resumen esO(n)

Otra referencia:

matriz dinámica

Nota adicional 1:

Si la complejidad de la inserción al final de la matriz es O(N), entonces la complejidad total es O(N^2), no O (2 * N) como otras respuestas dijeron. Porque la complejidad total para la inserción sería:1 + 2 + 3 + ...+ n = n*(n+1)/2

Nota adicional 2:

como dice el documento oficial :

Las operaciones size, isEmpty, get, set, iterator y listIterator se ejecutan en tiempo constante. La operación de agregar se ejecuta en tiempo constante amortizado , es decir, agregar n elementos requiere tiempo O (n). Todas las demás operaciones se ejecutan en tiempo lineal (aproximadamente). El factor constante es bajo en comparación con el de la implementación de LinkedList.

Nota adicional 3:

Aquí está la lógica del growmétodo que he tomado del código fuente oficial de Java:

private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

Como ha dicho el código fuente, cuando el programa agrega un elemento que hace que el tamaño de la matriz sea mayor que la capacidad actual, la matriz crecerá. El nuevo tamaño de la matriz desarrollada será:

int newCapacity = oldCapacity + (oldCapacity >> 1);

Este es un truco que hace que la inserción sea amortized O(1)

Respuesta 1

Estás haciendo una iteración, y eso es de O (n).

También está agregando elementos a una ArrayList, que es de O (1) ( Amortized )

Obtener un índice también es O (1).

Entonces estás haciendo O (n) veces, operaciones de O (1), que será de O (n) .

Respuesta: 2

El menú principal de mi aplicación (un juego) usa botones estándar de Android. Funciona bien en todos mis dispositivos, excepto en Nexus 7 con Android 4.4.2. El problema es el siguiente: el texto de un botón desaparece repentinamente ...

Hola, creé un recurso JNDI en el servidor Tomcat 7 y estoy tratando de usarlo a través de persistence.xml, pero recibí un error de que el nombre del recurso no se encuentra en el contexto. Probé otra solución encontrada en ...

Estoy adoptando un enfoque totalmente Java para la configuración de Spring MVC y no puedo entender cómo asociar un MultipartConfigElement con mi DispatcherServlet mediante programación. La documentación de primavera dice: ...

¿Hay alguna manera de que pueda ejecutar un método en una clase cada vez que se invoca cualquier método de esa clase? Daré un resumen de mi escenario aquí: Class Util {private isConnected () {...