Transcrições
1. Apresentação: Olá a todos. Bem-vindo a esta aula sobre
os algoritmos mais fundamentais. Esta aula lhe dará aulas
práticas para implementar alguns dos algoritmos mais básicos do zero. Se você é iniciante em programação ou é um programador experiente, esta aula será útil. Isso lhe dará a
oportunidade de voltar ao básico e rever como as porcas e
os parafusos de alguns
dos algoritmos mais fundamentais se encaixam. Eu ensino usando uma
linguagem muito simples, sem jargão. Primeiro, a lógica é
explicada no papel
e, em seguida, o programa
é desenvolvido do zero usando a ferramenta PyCharm. Você precisará de um computador
com conexão à internet. E para o
Anaconda e o PyCharm do software. Por favor, considere o comprimento do osso do calcanhar para o processo de instalação. Você deve estar pronto
para escrever e executar programa no ambiente
PyCharm. Antes de começar este curso. No final, você dominará esses algoritmos básicos e novos programadores desenvolverão um apetite por
mais programação. O que se segue depois disso
é para aulas sobre alguns dos algoritmos mais básicos e para diferenciar
a implementação do zero. Listen tem uma
manipulação simples como aquecimento. lição 3.4 é sobre
busca binária e particionamento de edição, algoritmos
muito básicos,
como você sabe. Finalmente, em menos de cinco, temos um projeto de classe sobre implementação do
algoritmo Quicksort do zero. Isso é tudo sobre isso. Estou ansioso para
ver todos vocês lá.
2. Matriz: Olá a todos. Nesta lição, aprenderemos sobre um tipo de dados
muito básico que pode armazenar vários
objetos juntos. Isso é chamado de matriz. Uma matriz é um conjunto de objetos armazenados lado a lado
na memória do computador. Em nossa discussão,
tomaremos números inteiros como objetos. Vamos dar um exemplo. É uma matriz contendo
os números 289214 menos seis em Python. E a matriz também é
chamada de lista. Os elementos são colocados
lado a lado na memória. A posição de cada
elemento da matriz é conhecida como índice. O índice começa em zero. Isso significa que o índice
do primeiro elemento é zero. índice do segundo
elemento é um, índice do terceiro elemento
é dois e assim por diante. Dessa forma, o índice
do último elemento é um a
menos que o
comprimento total da matriz. Portanto, na matriz dada, existem cinco elementos
e os índices são 01234. Vamos ver como podemos
acessar cada elemento de uma determinada matriz e imprimir
os números. Em Python. função de impressão é
usada para impressão. função de
impressão pode imprimir o total somado em uma
chamada para esta função. Isso significa que a função de impressão conhece a
estrutura interna da matriz. Para acessar cada
elemento da matriz, precisamos percorrer a
matriz usando um loop for. Esse for-loop imprime cada
elemento da matriz. O próximo loop for
percorre cada índice
da matriz e imprime o
valor nesse índice. Esse loop for
percorre cada índice e os
valores correspondentes simultaneamente e imprime os dois. Eu sugiro que você descubra mais
sobre essas duas funções, range e enumerate, pois elas são muito úteis
para escrever um loop. Em seguida, implementaremos
um algoritmo para calcular a soma contínua
de uma matriz de números inteiros. Então, o que é soma corrente? soma do elemento de
uma matriz é a soma de todos os elementos de zero a Pi. Então, após a soma, obtemos o vale superior como a soma contínua
da matriz original. soma corrente para o primeiro
elemento é o próprio elemento. soma corrente para
o segundo elemento é a soma dos
dois primeiros elementos. soma corrente para o
terceiro elemento é a soma de três
elementos e assim por diante. Gostamos das etapas
em uma linguagem simples e tentamos visualizar como o algoritmo é
executado passo a passo. Vamos tentar visualizar
esse algoritmo. Comece com um ponteiro p
no segundo elemento de a. Então, temos um ponteiro p. Vamos fazer com que ele aponte para o
segundo elemento que é a. Então aqui p é um ponteiro, que significa que ele contém o valor do Então, temos um ponteiro p.
Vamos fazer com que ele aponte para o
segundo elemento que é a.
Então aqui p é um ponteiro, o
que significa que ele contém o valor do
índice do segundo
elemento, que é um. Então, atualmente P é igual a um. Agora, precisamos
substituir o valor em p pela soma de seu valor
e o valor anterior. Isso significa que substituímos oito por oito mais
dois, o que é dez. Em seguida, damos um passo à frente
e fazemos a mesma coisa. Isso significa substituir 91 por 91 mais dez, o que é 101. Agora, vamos dar um passo à frente. Ele reproduz o valor de pela
soma de 4,101, que é 105. E continuamos da mesma forma. Então, mova B um passo à frente e substitua o valor
atual que é menos seis por menos seis mais
105, que é 99. E chegamos
ao final da matriz. Então, o algoritmo para aqui. Dessa forma, podemos encontrar a soma contínua de uma
determinada matriz de números. Observe que não
criamos nenhum novo LEA para
encontrar essa soma contínua, substituímos
cada elemento da matriz por seus correspondentes
. Em seguida, tentaremos
reverter isso, dado qualquer um, isso significa que dada uma matriz, digamos 289214 menos seis, inverteremos
a ordem dos elementos nessa matriz. Então, após a reversão, a matriz se
tornará menos 6492182. Vamos selecionar o algoritmo
em linguagem simples. Então, primeiro definimos dois ponteiros
no primeiro e no último elemento
da matriz, CPS e PE. Portanto, temos PAs e PE. Em seguida, precisamos trocar
os valores de P, S&P
e, em seguida, avançar uma etapa e PE
retroceder em uma etapa. Isso significa que movemos P, S&P um em direção ao outro em um
passo cada. E precisamos fazer esse movimento
de
uma etapa de cada um e trocar os valores correspondentes
até que eles se cruzem. Vamos fazer isso passo a passo e tentar ver o que realmente está
acontecendo. Portanto, temos P, S&P nos dois extremos. Precisamos trocar seus valores. Isso significa que precisamos trocar as posições de
dois e menos seis. Então trazemos para aqui, trazemos menos seis aqui para aqui. Em seguida, movemos o VS um passo à frente e o PE
um passo para trás. E, novamente, troque seus valores. Nós movemos cervejas e b0. Agora eles estão apontando
para o mesmo local. Então, soluçar não tem efeito. Basicamente. parar aqui ou se quisermos dar
o quarto passo, uma vez que o pai eu posso fazer isso e desde agora eles se
cruzaram. Nós paramos. Dessa forma. Podemos reverter os elementos
da matriz usando dois ponteiros. Espero que você entenda a ideia
por trás desses algoritmos. Nesta lição,
tentamos visualizar os estados de alguns dos
algoritmos mais básicos. Ainda não escrevemos
nenhum código Python. Na próxima lição,
escreveremos e executaremos algum código real
no ambiente Python. Então, isso é tudo para esta lição.
3. Algoritmo de partição: Olá a todos. Nesta lição, aprenderemos sobre particionamento. Então, o que é o particionamento de Ellie? Vamos explicar com um exemplo. Vamos pegar um
LEA com os seguintes números. Ou seja, 387-272-1402
particionando essa matriz, precisamos primeiro escolher um número
especial chamado pivô, que é um dos números
presentes na matriz. Digamos que escolhemos quatro
como o número do pivô. Precisamos reorganizar os
números na matriz. Então, depois de reorganizar todos os números
à esquerda do pivô, ou menores ou iguais
ao valor do pivô. E todos os números
à direita
do pivô são maiores
ou iguais ao valor do pivô. Se considerarmos o SDP vert
, uma possível solução pode
ser mostrada na tela. A solução é 032-14-7078. Observe que os números à esquerda
do pivô são
menores que iguais a quatro. Números à direita de
quatro, iguais a quatro. A submatriz esquerda e as pernas não são necessariamente
ordenadas por si mesmas. Observe também que, se tivéssemos
classificado a matriz inteira, depois de particionar,
a posição, o pivô, ficaria igual à posição que
obteria depois de classificar
a matriz inteira. Extraia para desenvolver um algoritmo para particionar esse determinado LA. Vamos examinar o
algoritmo passo a passo. Primeiro, precisamos colocar o pivô na primeira
localização dessa matriz. Em seguida, precisamos
pegar dois ponteiros, P1 e P2, e fazê-los apontar para os
dois primeiros elementos, respectivamente. Então p1 aponta para o primeiro elemento e v2
aponta para o segundo elemento. Então, precisamos mover o P2 um passo de cada vez
até o final deste LA. E ao mover isso, em cada etapa,
precisamos fazer algo
chamado check and swap. Então, o que precisamos
fazer da seguinte maneira? Em cada posição de P2, precisamos verificar se o valor em p2 é menor ou
igual ao pivô. Se não, então não faça nada. Mas se sim, precisamos incrementar o
outro ponteiro p1 uma etapa e, em seguida, trocar
os valores de P1 e P2 parará quando P2 atingir
o final da matriz. Vamos executar as etapas. Portanto, atualmente P2 está na posição dois e
seu valor é oito. Portanto, P2 não é
menos do que b trabalhou. Portanto, ambos devem ser entregues em uma única etapa. Então 77 é novamente não
menos que igual a quatro. Então, movemos o P2 em uma etapa. Agora, dois é
menos do que o pivô para. Então, precisamos fazer
essa subetapa aqui. Então, o que precisamos fazer agora
é mover p1 um passo à frente e, em seguida, trocar os valores de P1 e P2. Então, novamente, mova P2 em um passo. E, novamente, vemos
que o valor em P2, que está ligado, é
menor ou igual a quatro. Portanto, precisamos executar novamente
essa etapa de troca, que é a primeira transformação de
P1 em uma etapa. Em seguida, troque os
valores de P1 e P2. Novamente, mova P2 em um passo. E, novamente, observamos
que o valor em P2, que é três, é
menor ou igual a quatro. Então, novamente movemos p1 em uma
etapa e, em seguida, fazemos a troca. Mais 321 passos. E vemos que zero é novamente
menor que igual a quatro. Então, movemos um por um passo
e depois fazemos a troca. Nesse ponto, P2 está
no final dessa matriz. Então, o loop sobre P2 terminou. Agora, como última etapa, precisamos trocar a primeira
localização da matriz,
que é o valor do pivô, por p1. Isso colocará o pivô em
seu local de classificação correto. E agora vemos que todos os números à esquerda do pivô ou menores que
são iguais a quatro. E todos os números
à direita do pivô são maiores que iguais
ao valor do pivô para. Essa é uma
partição válida da matriz. Espero que isso tenha ajudado
a visualizar as etapas internas ao
aprender o algoritmo. Em seguida, examinaremos
o código Python para esse algoritmo de partição. Aqui está uma função Python
chamada partição, que recebe uma entrada chamada a, que é Danny, e particiona em
relação a um pivô. E isso pressupõe que o pivô esteja localizado na primeira
posição dessa matriz. Vamos examinar esse
algoritmo linha por linha. Primeiro a inicializar
os dois ponteiros, p1 e p2 a 0,1, respectivamente. Em seguida, definimos o pivô lendo a primeira localização da
matriz que é zero. Então, como mencionamos anteriormente, gostamos de examinar o P2. Portanto, P2 se move de sua localização atual até
o final da matriz. O final da matriz é
indicado pelo comprimento da matriz. Em seguida, na próxima declaração if, implementamos a lógica
que discutimos anteriormente. Ou seja, se a de p2 for
menor que igual ao pivô, movemos p1 e trocamos
os valores de P1 e P2. Esta linha AFP uma
vírgula f p2 é igual a f B2 vírgula f de p1 é a expressão Python
para trocar dois valores. Aqui, os valores são
a de P1 e P2. Portanto, essa é uma sintaxe muito
intuitiva. E então comece
esta declaração if, continuamos movendo P2, bem, uma etapa em cada
iteração desse loop while. E quando eles saem
do loop while, ou seja, isso significa que quando P2 atinge
o final da matriz, nós novamente trocamos
é zero e a de P1. Isso é para trazer o pivô
de sua localização atual, que é o início
da matriz, até sua localização final. E isso é tudo para esta lição.
4. Programa Python: Olá a todos. Nesta lição, executaremos o programa Python para particionamento de
matrizes. Aqui temos a função de partição
que já vimos. Além disso, há uma função principal
que cria uma lista chamada minha lista e chama a função de partição
com minha lista como entrada. Vamos executar o programa
no modo de depuração. Vamos colocar um ponto de interrupção na função
principal e executá-lo. Então, estamos no ponto de interrupção. E vamos primeiro criar
a lista, minha lista. Fique de olho na seção dessas
variáveis e você poderá ver os valores das variáveis. Em seguida, entre na função de
partição. Primeiro inicialize p1 e
p2, os dois ponteiros. E então defina o pivô, que assumimos o primeiro elemento
da matriz de entrada. Então, aqui o pivô é quatro. Vamos inserir o loop sobre P2. Portanto, P2 se move de sua localização atual para
o final da matriz. Primeiro, se P2 for oito, o que não é menor que
igual ao período quatro. Então, passamos pela instrução if e vamos para a próxima
iteração do loop. Agora, se P2 for igual a 77, o que não é menor que
igual ao pivô. Então, passamos para a
próxima iteração. Agora, se P2 for dois, o que é menor que igual
ao pivô quatro. Então, entramos
na instrução if, incrementamos além de
u1 e fazemos a troca. Vamos para a próxima iteração. Agora o AF P2 está ligado. Então, novamente, insira a
instrução if e faça a troca. Na próxima iteração
de P2 é três, o que é menor que
igual ao pivô quatro. Então, novamente, inserimos a
instrução if e fazemos a troca. Na próxima iteração. Se B2 é zero, o que é menor que
igual a p, para quê? Então, inserimos a instrução if
e fazemos a troca novamente. E agora o P2 chegou
ao final da matriz. Então, saímos
do ciclo while. E então fazemos a troca final, o valor do pivô, que está
no primeiro local com b1. E isso completa
o algoritmo. Não na seção de variáveis. Você pode ver o
estado atual da lista mental. E foi particionado. Então, todos os números
à esquerda de quatro ou
menores que são iguais a quatro e todos os números à direita de quatro ou
maiores que são iguais a quatro. Então, se eu tivesse que explicar todo
o algoritmo em
uma linguagem muito simples, seria assim. Existem dois
ponteiros, p1 e p2. O que eles realmente fazem? B1 mantém um limite
entre as duas partições. A partição esquerda, que vai do início
da matriz até p1, é o conjunto de números que são menores que iguais ao valor
do pivô. E os números
à direita de P1 são os números maiores do que iguais
ao valor do pivô. Então, como p1 e
p2 conseguem isso? B2 explode cada novo
número da matriz. E se esse número
recém-explorado for menor que igual
ao valor do pivô
, B1 estende
o limite esquerdo e esse novo número é
movido para a partição esquerda. Ao trocar. Dessa forma, a partição esquerda sempre contém valores
menores que iguais ao pivô. E a partição certa contém valores maiores do que iguais
ao valor do pivô. Observe que a partição correta começa após T1 e
se estende até P2. Eu sugiro que você passe por este programa em seu ambiente de
programação Python. Para que as etapas internas
se tornem muito claras para você. E isso é tudo para esta lição.
5. Algoritmo de busca binário: Olá a todos. Nesta lição, aprenderemos sobre a busca binária. Então, o que é busca binária? Aqui? Recebemos uma
matriz ordenada de números inteiros e também recebemos
outro único inteiro x, precisamos encontrar a localização
de x nessa matriz classificada a. Se x não estiver presente em a, então podemos retornar menos um. Vamos dar um exemplo. Recebemos a matriz classificada a, seja, você pode ver que é
classificada em ordem crescente. E também recebemos
outro número x. Precisamos encontrar
a localização de x. Se x estiver presente em a,
caso contrário, precisamos
retornar menos um. Então, aqui podemos ver que
sete está presente no LEA. E a localização de
sete é o índice quatro. Isso significa o quinto lugar. Então, precisamos devolver quatro. Nesse caso. Se o valor de x for, então podemos ver que nove
não está presente no dado a. Portanto, a busca binária
deve retornar menos um. Vamos tentar visualizar o algoritmo de busca
binária. Recebemos a matriz classificada, que é classificada em ordem
crescente. E precisamos pesquisar
um determinado número X em a. Aqui, o valor de x é sete, então precisamos pesquisar por sete. Em primeiro lugar, observe
que podemos percorrer toda
a matriz, um elemento
por vez, e procurar x. Isso levará n passos, onde n é o número total
de elementos na matriz. Se a matriz for muito longa, o tempo necessário para pesquisar dessa maneira também
será muito longo. Portanto, essa não é uma maneira eficiente. Se a matriz não
estiver classificada, teremos que
fazer dessa maneira. Mas agora a
matriz está classificada. Então, precisamos usar essa propriedade para acelerar nosso algoritmo. Vamos escrever o algoritmo
em uma linguagem simples. Primeiro, precisamos definir dois pontos no início
e no final da matriz. Digamos que o LPS
e p. Dissemos que P está no início
e p no final. Em seguida, encontramos o
ponto médio de P S&P. Isso significa
que encontramos P S mais p todos divididos por dois
e arredondados abaixo. Então, isso é chamado de ponto médio. Observe que isso é
deixado de forma tendenciosa. Isso significa que P S seguro é
dois e p é três. Então mate é dois mais 3/2. E essa divisão é
uma divisão inteira. Então, o resultado é dois. ponto médio de 2,3 é dois, ponto
médio de 23,4 é três. ponto médio de 234,5 é três. É por isso que é chamado de feito tendencioso
à esquerda. Vamos calcular a
média da corrente P S&P.
P S é zero e P é
70 mais sete por dois, o que é 3,5. Arredondado. Olá é três igual a três. Então, mid é colocado no índice três. Agora, estamos procurando por x. Então, comparamos o
valor em mim com x. Se x é igual a mate , você encontrou
a localização de x e retornamos o valor da carne. Se não, então x está à direita da carne
ou à esquerda da carne. Se x for maior que carne, então x está à direita da carne. E nesse caso, podemos contornar o que
está à esquerda da carne para que possamos descartar todo
o subconjunto,
o encontro de decolagem. Dessa forma, podemos reduzir o espaço de
pesquisa muito rapidamente. Portanto, em cada iteração, metade da matriz total
pode ser descartada. E isso torna essa busca
binária muito rápida. Agora, x é maior que três. Então, movemos o PS. Conheça mais um. Isso significa o logo à
direita do feito anteriormente. Agora sabemos que o que resta
à esquerda dos colegas
pode ser descartado. Reduzimos nosso espaço de
busca pela metade. Agora. Mais uma vez, me calcule. Então, atualmente PACs quatro e p é sete. Portanto, a carne de 4,7 é 5,5. Arredondado abaixo está cinco. Então, vamos nos encontrar às cinco. Agora, o valor da
carne é 88 não é igual a x. E vemos que agora
x é menor que mate. Então, movemos B para fazer menos um. Agora, na próxima iteração, novamente, calculamos o meio. Então você verá que, como PAs
e PE têm o mesmo valor, o valor da carne
também será o mesmo. Então, novamente, vamos apontar
para o mesmo local. Agora. X é igual a encontrar x. E nós retornamos, fizemos. Dessa forma. Podemos encontrar a localização
de x nos dados classificados. Agora vamos dar outro exemplo que x não está
presente no LA, digamos que x é igual a nove. Novamente, começamos com o
PAS no início. E no final. O meio aponta para o ponto médio. Comparamos o valor em, que é três
com x, x é nove. Então x deve estar
à direita da carne. Então, movemos o VS para encontrar mais um. E, novamente, calculamos
o que está aqui. Comparamos o valor x com x. O valor de x é nove, então nove é maior que oito. Então x deve ser a luz da carne. Então, movemos os PAs para o meio mais um. Agora calculamos o encontro novamente, seja, que
será o mesmo que bs. Comparamos x com Nate e
descobrimos que x é
menor que carne agora. Então, movemos B para o meio menos um. E nesta fase, observe que a P S&P se
cruza. Então paramos e retornamos menos um. Isso significa que, nesse caso, X não
está presente
nessa matriz classificada. Vamos dar uma olhada no código Python para a função de busca binária. A função aceita
dois argumentos. A primeira é a matriz, é uma matriz de números inteiros
ordenados em ordem crescente. E x é outro número inteiro. Precisamos encontrar a
localização de x dentro de a. E se x não estiver presente, retornaremos menos um. Vamos analisar a
função linha por linha. Primeiro, inicializamos P, S&P, os ponteiros de início e fim. Então p é, é inicializado em zero, ou o índice da localização
mais à esquerda. E PE é igual ao
comprimento de um menos um. Esse é o índice
da localização mais à direita. Em seguida, iniciamos o loop
while com a condição P S é
menor que igual a p. Isso significa que continuamos
com o loop while. Os dois ponteiros
não se cruzam. Primeiro, calculamos o mate,
que, como explicamos anteriormente, é o encontro tendencioso à esquerda. E então verificamos se x
é igual a a de mid. Isso significa uma estimativa de valor. Se a de mid é igual a x, então encontramos x e retornamos a localização
que foi feita. Caso contrário, então,
dependendo se x é maior que a ou x
é menor que a metade feita, descartamos metade da matriz. Então, se x for
maior que a de mid, descartamos a metade esquerda da matriz e o valor em si. Isso significa que definimos como
meio mais um. Se x for menor que m it. Em seguida, descartamos a parte
direita da matriz e configuramos p para o meio menos um. E, novamente, calculamos par com essas
localizações atualizadas da P S&P. E repetimos dessa maneira. Então, em cada iteração, descartamos metade da matriz. Então, no final, duas
coisas podem acontecer. Ou X é encontrado
e, nesse caso, retornamos a
localização correspondente de X ou X não foi encontrado. E P, S&P se cruzam. E saímos
disso enquanto fazemos um loop e retornamos menos
um. Nesse caso. Espero que você tenha uma ideia básica como esse
algoritmo de busca binária funciona. Isso é tudo para esta lição.
6. Programa Python: Olá a todos. Nesta lição, você aprenderá o programa Python
para pesquisa binária. Aqui está a função de
busca binária, que você já viu. Além disso, escrevemos uma função principal que
chama a busca binária. Então, vamos colocar um ponto de interrupção
na função principal e executá-lo. Então, estamos no ponto de interrupção. Então, primeiro, criamos uma matriz que já está
classificada. Como você pode ver. Fique de olho na seção de
variáveis, onde você pode ver os
valores atuais das variáveis. Definimos x a sete. E então chamamos função de busca
binária
com a e x como entradas. Queremos encontrar a
localização de X em a. Então, vamos entrar na função de busca
binária. Primeiro, P, S&P. Os ponteiros inicial e final foram inicializados em 0,7, respectivamente, como você verá na seção de
variáveis. Em seguida, inserimos o loop while com a condição P menor
que igual a p. Em seguida, calculamos que o
valor médio da mídia é três. E então verificamos se x
é igual ou menor que, igual ou menor ou
maior que a carne. Observe que quando
comparamos x com carne, o que realmente queremos dizer é o
valor no ponto a de meados, se for igual a atendê-lo e já o
encontrarmos, e a função retornará. Mas se não, então ele reinicia. Ou p é RPE, dependendo se x é
maior ou menor que. Vamos ver. Então aqui o valor
de x é sete, como sabemos, e a de mid é três. Então x não é igual a x
é maior que a metade. Então, redefinimos o ponteiro
ps para fazer mais um. Nesta etapa, descarte metade disso. Então vá para a próxima iteração. Com os novos valores de P S&P. O novo valor de P, S
é quatro e p é sete. Então, agora estamos
examinando a submatriz, começando no local da falha e até esse determinado local, calculamos o encontro novamente. O valor da carne agora é
cinco é igual a oito. Portanto, atualmente é
menos de um de meados. Então, ele vem aqui. E agora definimos p0
para meio menos um. Agora veja as
variáveis que a seção P, BE e PAs têm o mesmo
valor, que é quatro. Então, aponte para o mesmo
local na matriz. Nós calculamos o meio. Mid também
é para, obviamente. Então agora x é igual a f meet. E retornamos mid, que é o valor quatro. Então, retornamos
da função de busca binária
e o resultado é quatro. Isso significa que X está presente no índice quatro da matriz classificada. Vamos mudar X, 7-9. E, novamente,
siga este programa. Temos o mesmo LEA, que já está classificado. Definimos x como nove e depois
entramos na busca binária. Então P, S&P são inicializados. Inicie o loop. O valor da carne
inicialmente é três. Então x não é igual a
x é maior que m, é bs mais um. E continue até a
próxima iteração. E agora o MIT tem cinco anos. Portanto, AF feito não é igual
a x, é menor que x. Então, reiniciamos agora
ps para
colocar luvas e vamos para a próxima iteração. Calcule o encontro
novamente, que é seis. Então AF tomou sua decisão agora, que não é igual a x. Não, x é menor que a de meados. Certamente venha aqui e
faça um reset p menos um. Agora, observe que o valor de P, S é seis e o
valor de B é cinco. Isso significa que P e S&P
se cruzaram. Aqui, o loop while é interrompido
e retornamos menos um. Então você verá que o
resultado é menos um. Nesse caso, o valor de x não é encontrado
na matriz classificada, então ele retorna menos um. Eu sugiro que você passe por
essa função de pesquisa binária em seu
ambiente de desenvolvimento Python para se familiarizar
com as etapas internas. E chame essa função com diferentes matrizes classificadas
com comprimentos diferentes. E, assim, familiarize-se com o funcionamento interno
desse algoritmo. Isso é tudo para esta lição.
Suman Datta, just a coder
