Encontrar la relación recursiva de un algoritmo y luego utilizarla para determinar la complejidad de tiempo de ejecución utilizando el teorema maestro.

Estoy tratando de encontrar la relación recursiva de la siguiente función (pseudocódigo)

    def algoritmo(lista):
        lista_izquierda = []
        lista_derecha = []
        if len(lista) > 1:
            for i in range(0, len(lista)):
                if i <= len(lista) / 2:
                    lista_izquierda.append(lista[i]) //get se ejecuta en tiempo O(n)
                else:
                    lista_derecha.append(lista[i]) //get se ejecuta en tiempo O(n)
        izquierda = algoritmo(lista_izquierda)
        derecha = algoritmo(lista_derecha)
        lista = combinar(izquierda, derecha) //combine se ejecuta en tiempo O(1)
        return lista

El objetivo es encontrar el tiempo de ejecución Theta(n) de la función utilizando el teorema maestro, así que he seguido el siguiente proceso:

Número de subproblemas por llamada recursiva: 2 –> Referido como A

Tamaño de los subproblemas en comparación con la lista de entrada: n/2 –> Referido como B

Trabajo realizado para cada llamada recursiva: Theta(n^2) // n (el bucle for) * n (la operación get) –> Exponente referido como k

Esto me lleva a la siguiente ecuación:

T(n) = AT(n/b) + Theta(n^k)
T(n) = 2T(n/2) + Theta(n^2)

Utilizando el teorema maestro:

Queremos comparar log_b(a) con k

log₂(2) = 1

k = 2

1 < 2

Esto significa que caemos bajo la condición del teorema maestro que establece que si log_b(a) < k, entonces T(n) es Theta(n^k), lo cual en mi situación significa que T(n) = Theta(n^2).

Esta respuesta me parece lógica, pero estoy buscando confirmación de que he identificado todas las partes correctamente y que también aplico correctamente el teorema maestro.