O bissectar O módulo em Python fornece funções simples e rápidas (baseadas em pesquisa binária) para pesquisar um elemento em uma lista classificada, encontrar a posição correta para inserir novos elementos e inserir novos elementos garantindo que a lista permaneça classificada.

Por que precisamos do Módulo Bisect?

1. Útil para operações de pesquisa binária para pesquisar em uma lista ordenada e localizar pontos de inserção.
2. Fornece métodos eficientes para inserir elementos em uma lista classificada enquanto mantém a ordem.
3. Evita a necessidade de classificação manual após cada inserção, economizando tempo e esforço.
4. Oferece funções como bisect() bisect_left() bisect_right() e insort() para código limpo e otimizado.
5. Ideal para tarefas como manutenção de dados classificados em tabelas de classificação ou qualquer cenário que envolva inserção/pesquisa de dados classificados.

Funções principais do módulo Bisect

O módulo bisect oferece principalmente dois tipos de funcionalidades:

• Encontrando o ponto de inserção (sem inserção)
• Inserindo elementos na posição correta

1. Encontrando pontos de inserção

Estas funções retornam o índice onde o novo elemento deve ser inserido para manter a lista ordenada.

a) bisect.bisect(): Retorna o ponto de inserção mais à direita do elemento. Se o elemento já existir o ponto de inserção estará após as entradas existentes.

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

Parâmetro:

• lista: Lista ordenada.
• num: Elemento a inserir.
• implorar: Inicie o índice para pesquisa (opcional).
• fim: Índice final para pesquisa (opcional).

b) bisect.bisect_left(): Retorna o ponto de inserção mais à esquerda do elemento. Se o elemento existir, o ponto de inserção estará antes das entradas existentes.

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

c) bisect.bisect_right(): Idêntico a bisect.bisect() retorna o ponto de inserção mais à direita.

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

Exemplo: Encontre índices de inserção para o valor 4 em uma lista ordenada usando diferentes funções de bissecção.

   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ção:

• bissetar (li 4): Retorna 5 porque encontra a posição mais à direita após os últimos 4 da lista (índice 4), portanto o ponto de inserção é 5.
• bisect_left(li 4): Retorna 2 porque encontra a posição mais à esquerda antes dos 4 primeiros da lista (índice 2).
• bisect_right(li 4 0 4): Funciona apenas na sublista isso[0:4] e retorna 4 porque insere 4 após os últimos 4 da sublista.

2. Inserindo Elementos

Essas funções inserem o elemento na posição adequada para manter a classificação.

a) bisect.insort(): Insere o elemento na posição mais à direita. Ao contrário das funções bisect(), isso na verdade modifica a lista inserindo o elemento.

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

Parâmetro:

• lista: Lista ordenada.
• num: Elemento a inserir.
• implorar (opcional): Índice inicial para inserção (padrão 0).
• fim (opcional): Índice final para inserção (len (lista) padrão).

b) bisect.insort_left(): Insere o elemento na posição mais à esquerda.

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

c) bisect.insort_right(): Insere o elemento na posição mais à direita (semelhante a insort()).

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

Exemplo: Insira o valor 5 em uma lista ordenada, mantendo-a ordenada usando diferentes estratégias de inserção.

   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ção:

• surgir(l1 5) insere 5 na posição adequada mais à direita – depois de todos os 4s e antes de 6.
• sort_left(l2 ​​5) insere 5 na posição adequada mais à esquerda – o mesmo que insort aqui, já que 5 não está na lista.
• inserir_right(l3 5 0 4) insere 5 no índice 4 trabalhando apenas na sublista l3[0:4] = [1 3 4 4] após o último ≤ 5 nesse intervalo sem afetar o resto da lista.