The împărţi în două modulul din Python oferă funcții simple și rapide (pe bază de căutare binară) pentru a căuta un element într-o listă sortată, găsiți poziția corectă pentru a insera elemente noi și a insera elemente noi, asigurându-vă că lista rămâne sortată.

De ce avem nevoie de modulul Bisect?

1. Util pentru operațiuni de căutare binară pentru a căuta într-o listă sortată și pentru a localiza punctele de inserare.
2. Oferă metode eficiente de inserare a elementelor într-o listă sortată, menținând ordinea.
3. Evita necesitatea sortarii manuale dupa fiecare inserare economisind timp si efort.
4. Oferă funcții precum bisect() bisect_left() bisect_right() și insort() pentru codul optimizat curat.
5. Ideal pentru sarcini precum menținerea datelor clasate în clasamente sau orice scenariu care implică inserarea/căutarea datelor sortate.

Funcțiile de bază ale modulului Bisect

Modulul bisect oferă în principal două tipuri de funcționalități:

• Găsirea punctului de inserare (fără inserare)
• Introducerea elementelor în poziția corectă

1. Găsirea punctelor de inserare

Aceste funcții returnează indexul în care ar trebui să fie inserat noul element pentru a menține lista sortată.

a) bisect.bisect(): Returnează punctul de inserare din dreapta pentru element. Dacă elementul există deja, punctul de inserare va fi după intrările existente.

bisect.bisect(list num beg=0 end=len(list))

Parametru:

• listă: Lista sortată.
• num: Element de inserat.
• implora: Începeți indexul pentru căutare (opțional).
• Sfârşit: Încheierea indexului pentru căutare (opțional).

b) bisect.bisect_left(): Returnează punctul de inserare din stânga pentru element. Dacă elementul există, punctul de inserare va fi înaintea intrărilor existente.

bisect.bisect_left(list num beg=0 end=len(lista))

c) bisect.bisect_right(): Identic cu bisect.bisect() returnează punctul de inserare din dreapta.

bisect.bisect_right(list num beg=0 end=len(lista))

Exemplu: Găsiți indici de inserție pentru valoarea 4 într-o listă sortată folosind diferite funcții bisect.

   import   bisect   li   =   [  1     3     4     4     4     6     7  ]   print  (  bisect  .  bisect  (  li     4  ))   # right   print  (  bisect  .  bisect_left  (  li     4  ))   # left   print  (  bisect  .  bisect_right  (  li     4     0     4  ))   # subright   

5 2 4  

Explicaţie:

• bisect (li 4): Returnează 5 deoarece găsește poziția cea mai din dreapta după ultimele 4 din listă (index 4), deci punctul de inserare este 5.
• bisect_left(li 4): Returnează 2 deoarece găsește poziția cea mai din stânga înaintea primelor 4 din listă (index 2).
• bisect_right(li 4 0 4): Funcționează numai pe sublistă că[0:4] și returnează 4 deoarece inserează 4 după ultimele 4 din sublistă.

2. Inserarea elementelor

Aceste funcții introduc elementul în poziția corectă pentru a menține sortarea.

a) bisect.insort(): Inserează elementul în poziția cea mai din dreapta. Spre deosebire de funcțiile bisect(), aceasta modifică de fapt lista prin inserarea elementului.

bisect.insort(list num beg=0 end=len(lista))

Parametru:

• listă: Lista sortată.
• num: Element de inserat.
• cerși (opțional): Index de pornire pentru inserare (implicit 0).
• sfârșit (opțional): Index final pentru inserare (len (listă) implicită).

b) bisect.insort_left(): Inserează elementul în poziția cea mai din stânga.

bisect.insort_left(list num beg=0 end=len(lista))

c) bisect.insort_right(): Inserează elementul în poziția cea mai din dreapta (similar cu insort()).

bisect.insort_right(list num beg=0 end=len(lista))

Exemplu: Introduceți valoarea 5 într-o listă sortată, menținând-o sortată folosind diferite strategii de inserare.

   import   bisect   l1   =   [  1     3     4     4     4     6     7  ]   l2   =   [  1     3     4     4     4     6     7  ]   l3   =   [  1     3     4     4     4     6     7  ]   bisect  .  insort  (  l1     5  )   # right   print  (  l1  )   bisect  .  insort_left  (  l2     5  )   # left   print  (  l2  )   bisect  .  insort_right  (  l3     5     0     4  )   # subright   print  (  l3  )   

[1 3 4 4 4 5 6 7] [1 3 4 4 4 5 6 7] [1 3 4 4 5 4 6 7]  

Explicaţie:

• apare(l1 5) introduce 5 în poziția cea mai potrivită din dreapta - după toate cele 4 și înainte de 6.
• sortare_stânga(l2 5) inserează 5 în poziția cea mai potrivită din stânga – la fel ca în sortare aici, deoarece 5 nu este în listă.
• insort_right(l3 5 0 4) inserează 5 la indexul 4 lucrând numai pe sublista l3[0:4] = [1 3 4 4] după ultimii ≤ 5 din acel interval fără a afecta restul listei.