Quali sono i modi efficaci per elaborare elenchi enormi (+10 milioni) e cose da considerare mentre si manipolano elenchi enormi.
Prima domanda, quando dovrei usare la ricorsione e quando non dovrei. In entrambi i casi, stiamo allocando memoria per archiviare i dati (la complessità della memoria dovrebbe essere uguale), l'utilizzo dell'approccio ricorsivo con una lista enorme comporterebbe un consumo di memoria (immagazzinare la chiamata nella memoria Heap), così come la memorizzazione dei dati in un lista (stack-memory). Quale approccio con meno costi? (Di solito possiamo scrivere qualsiasi algoritmo ricorsivo per algoritmo iterativo).
Seconda domanda, quando si tratta di memoria-comlessità, dovrei pensare di trasformare questa lista in un'altra struttura dati (come LL, BST, .. per manipolare facilmente i dati), il problema con tali soluzioni è che l'allocazione di memoria in questo caso verrebbe raddoppiato (ogni nodo avrebbe valore di riferimento + nodo invece di un valore in una lista).
O dovrei pensare a copiare su disco questo elenco (testo-dati o csv) e elaborare i dati per porzione. Il problema di questa soluzione è che alcune operazioni richiedono la correlazione tra i valori, non è possibile elaborare ogni porzione in modo indipendente, quindi ridurre e concatenare i dati.
Scenario 1: ordinamento di una lista enorme (Merge Sort (Ricorsive) Vs altri)
Scnario 2: consideriamo questo rapido esempio (non è il pefetto e il più pertinente a ciò che sto cercando di chiedere, ma solo per mostrare un altro esempio).
Stiamo aggiungendo il prodotto di 4 elementi successivi a ogni elemento di questi quattro elementi.
L=range(100)
from operator import mul
def prodElement(L):
getItems= lambda i: L[i:i+4]
list_mul=[]
for i in xrange(0,len(L)-3,4):
p=reduce(lambda x,y:x*y,getItems(i))
L[i],L[i+1],L[i+2],L[i+3]= L[i]+p,L[i+1]+p,L[i+2]+p,L[i+3]+p
return L
def prodElement_rec(r,L,i=0):
if i>=len(L)-1: #Stop
return res
else:
if i%4==0 or i==0:
p= L[i]*L[i+1]*L[i+2]*L[i+3]
L[i],L[i+1],L[i+2],L[i+3]= L[i]+p,L[i+1]+p,L[i+2]+p,L[i+3]+p
return prodElement_rec(r,L,i+4)
res=[]
assert prodElement_rec(res,L)==prodElement(L)
Ancora una volta, non sto cercando di risolvere un problema specifico, ma sto cercando di capire i migliori approcci da utilizzare quando si tratta di elenchi enormi (+10 milioni di articoli). Quali sono i metodi che dovrei pensare e le questioni critiche che dovrei evitare per risolvere il problema usando liste enormi.