De halvera modul i Python tillhandahåller enkla och snabba (binära sökbaserade) funktioner för att söka efter ett element i en sorterad lista hitta rätt position för att infoga nya element och infoga nya element för att säkerställa att listan förblir sorterad.

Varför behöver vi Bisect Module?

1. Användbar för binära sökoperationer för att söka i en sorterad lista och för att hitta insättningspunkter.
2. Ger effektiva metoder för att infoga element i en sorterad lista med bibehållen ordning.
3. Undviker behovet av manuell sortering efter varje insättning vilket sparar tid och ansträngning.
4. Erbjuder funktioner som bisect() bisect_left() bisect_right() och insort() för ren optimerad kod.
5. Idealisk för uppgifter som att underhålla rankad data på topplistor eller andra scenarion som involverar infogning/sökning av sorterad data.

Kärnfunktioner i Bisect-modulen

Bisect-modulen erbjuder huvudsakligen två typer av funktioner:

• Hitta insättningspunkten (utan infogning)
• Sätt in element i rätt position

1. Hitta insättningspunkter

Dessa funktioner returnerar indexet där det nya elementet ska infogas för att hålla listan sorterad.

a) bisect.bisect(): Returnerar insättningspunkten längst till höger för elementet. Om elementet redan finns kommer insättningspunkten att ligga efter de befintliga posterna.

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

Parameter:

• lista: Sorterad lista.
• num: Element att infoga.
• tigga: Starta index för sökning (valfritt).
• avsluta: Slutindex för sökning (valfritt).

b) bisect.bisect_left(): Returnerar insättningspunkten längst till vänster för elementet. Om elementet finns kommer insättningspunkten att vara före de befintliga posterna.

pyspark sql

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

c) bisect.bisect_right(): Identiskt med bisect.bisect() returnerar insättningspunkten längst till höger.

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

Exempel: Hitta insättningsindex för värdet 4 i en sorterad lista med hjälp av olika halveringsfunktioner.

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 

Förklaring:

• dela(li 4): Returnerar 5 eftersom den hittar positionen längst till höger efter de sista 4 i listan (index 4) så insättningspunkten är 5.
• bisect_left(li 4): Returnerar 2 eftersom den hittar positionen längst till vänster före de första 4 i listan (index 2).
• bisect_right(li 4 0 4): Fungerar endast på underlista det[0:4] och returnerar 4 eftersom det infogar 4 efter de sista 4 i underlistan.

2. Infoga element

Dessa funktioner sätter in elementet i rätt position för att upprätthålla sorteringen.

a) bisect.insort(): Infogar elementet längst till höger. Till skillnad från funktionerna bisect() ändrar detta faktiskt listan genom att infoga elementet.

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

stad i uas

Parameter:

• lista: Sorterad lista.
• num: Element att infoga.
• tigga (valfritt): Startindex för infogning (standard 0).
• slut (valfritt): Slutindex för infogning (standard len(lista)).

b) bisect.insort_left(): Infogar elementet längst till vänster.

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

c) bisect.insort_right(): Infogar elementet längst till höger (liknar insort()).

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

Exempel: Infoga värdet 5 i en sorterad lista samtidigt som den är sorterad med hjälp av olika infogningsstrategier.

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] 

Förklaring:

• uppstå(l1 5) sätter in 5 i den lämpligaste positionen till höger – efter alla 4:or och före 6.
• insort_left(l2 ​​5) infogar 5 vid den lämpliga positionen längst till vänster – samma som infogar här eftersom 5 inte finns i listan.
• insort_right(l3 5 0 4) infogar 5 vid index 4 som endast fungerar på underlistan l3[0:4] = [1 3 4 4] efter de sista ≤ 5 i det intervallet utan att påverka resten av listan.