Transcripciones
1. Introducción: Hola a todos. Bienvenidos a esta clase sobre
los algoritmos más fundamentales. Esta clase te dará lecciones
prácticas para implementar algunos de los algoritmos más básicos desde cero. Si eres nuevo en la programación o eres un programador experimentado, esta clase te será útil. Esto te dará la
oportunidad de volver
a lo básico y revisar cómo encajan las tuercas y
tornillos de algunos de los
algoritmos más fundamentales. Enseño usando un
lenguaje muy sencillo, sin jerga. Primero, la lógica se
explica en papel, y luego el programa
se desarrolla desde cero usando la herramienta PyCharm. Necesitarás una computadora
con conexión a internet. Y a
Anaconda y PyCharm del software. Por favor tome la longitud del hueso del talón para el proceso de instalación. Debes estar listo para
escribir y ejecutar programa dentro del entorno
PyCharm. Antes de iniciar este curso. Al final, dominarás estos algoritmos básicos y los nuevos programadores desarrollarán un apetito por
más programación. Lo que sigue después de esto
es para lecciones sobre algunos de los algoritmos más básicos y contar la implementación
desde cero. Escuchar tiene alguna
manipulación simple como calentamiento. La lección 3.4 son sobre la
búsqueda binaria y el particionamiento de edición, algoritmos
muy básicos
como ustedes saben. Finalmente, en menos de cinco, tenemos un proyecto de clase sobre la implementación del
algoritmo Quicksort desde cero. Eso es todo sobre eso. Esperando
verlos a todos ahí.
2. Matriz: Hola a todos. En esta lección, aprenderemos sobre un tipo de datos
muy básico que puede almacenar múltiples
objetos juntos. Esto se llama matriz. Una matriz es un conjunto de objetos almacenados uno al lado del otro
en la memoria de la computadora. En nuestra discusión,
tomaremos números enteros como objetos. Tomemos un ejemplo. Es una matriz que contiene
los números 289214 menos seis en Python. Y array también se
llama la lista. Los elementos se colocan
uno al lado del otro en la memoria. La posición de cada
elemento de matriz se conoce como índice. El índice comienza en cero. Eso significa que el índice
del primer elemento es cero. índice del segundo
elemento es uno, índice del tercer elemento
es dos, y así sucesivamente. De esta manera, el índice
del último elemento es uno menor que la
longitud total de la matriz. Entonces en la matriz dada, hay cinco elementos
y los índices son 01234. Veamos cómo podemos
acceder a cada elemento de una matriz dada e imprimir
los números. En Python. La función de impresión se
utiliza para la impresión. función de
impresión puede imprimir la totalidad sumada en una sola
llamada a esta función. Eso significa que la función print conoce la
estructura interna de la matriz. Para acceder a cada
elemento de la matriz, necesitamos atravesar la
matriz usando un bucle for. Este for-loop imprime cada
elemento de la matriz. El siguiente bucle for
pasa por cada índice de la matriz e imprime el
valor en ese índice. Este bucle for
pasa por cada índice y los
valores correspondientes simultáneamente e imprime ambos. Te sugiero que entres más
sobre estas dos funciones, range y enumerate, ya que son muy útiles para
escribir un bucle. A continuación, implementaremos
un algoritmo para calcular la suma corriente
de una matriz de enteros. Entonces, ¿qué es la suma corriente? Suma para elemento de
una matriz es la suma de todos los elementos de cero a Pi. Entonces después de sumar, obtenemos el valle superior como la suma corriente de
la matriz original. Suma corriente para el primer
elemento es el elemento en sí. suma corriente para
el segundo elemento es la suma de los
dos primeros elementos. Suma corriente para el
tercer elemento es la suma de tres
elementos y así sucesivamente. Nos gustan los pasos
en lenguaje sencillo e intentamos visualizar
cómo se
ejecuta el algoritmo paso a paso. Intentemos visualizar
este algoritmo. Comienza con un puntero p en
el segundo elemento de a. Entonces tenemos un puntero p. Hagámoslo señalar al
segundo elemento que es a. Entonces aquí p es un puntero, eso significa que contiene el valor
del índice del segundo
elemento, que es uno. Por lo que actualmente P es igual a uno. Ahora, necesitamos
reemplazar el valor en p por la suma de su valor
y el valor anterior. Eso significa que reemplazamos ocho por ocho más
dos, que es diez. Entonces avanzamos un paso adelante
y hacemos lo mismo. Eso significa sustituir 91 por 91 más diez, que es 101. Ahora, avanzamos un paso adelante. Juega el valor para por la
suma de 4.101, que es 105. Y seguimos de la misma manera. Así que mueve B un paso adelante y reemplaza el valor
actual que es menos seis por menos seis más
105, que es 99. Y hemos llegado
al final de la matriz. Entonces el algoritmo se detiene aquí. De esta manera, podemos encontrar la suma corriente de una matriz
dada de números. Tenga en cuenta que no hemos creado ninguna nueva LEA para
encontrar esta suma corriente, hemos reemplazado
cada elemento del array por su correspondiente
ejecutando algunos. A continuación, intentaremos
revertir eso dado cualquiera, eso significa dado un array, digamos 289214 menos seis, invertiremos el orden de
los elementos en esa matriz. Entonces después de revertir, la matriz se
convertirá en menos 6492182. Seleccionemos el algoritmo
en lenguaje sencillo. Así que primero establecemos dos punteros en el primer y último elementos
de la matriz, CPS y PE. Entonces tenemos PA y PE. Entonces necesitamos intercambiar
valores de P, S&P, y luego avanzar
un paso y PE
hacia atrás en un paso. Eso significa que movemos P, S&P el uno hacia el otro en un
paso cada uno. Y necesitamos hacer este movimiento de
un paso de cada uno e intercambiar los valores correspondientes
hasta que se crucen entre sí. Hagamos esto paso a paso y tratemos de ver qué está
pasando en realidad. Entonces tenemos P, S&P en los dos extremos extremos. Tenemos que intercambiar sus valores. Eso significa que necesitamos intercambiar las posiciones de
dos y menos seis. Entonces traemos hasta aquí, traemos menos seis aquí hasta aquí. Después movemos VS un paso adelante y PE
un paso atrás. Y nuevamente intercambian sus valores. Nos movemos cervezas y b0. Ahora están apuntando
a la misma ubicación. Por lo que sollozar no tiene efecto. Básicamente. parar aquí o si queremos ir
al paso cuatro, una vez el padre
puedo hacer esto y desde ahora se han
cruzado entre sí. Nos detenemos. De esta manera. Podemos revertir los elementos de la matriz usando dos punteros. Espero que se te ocurra la idea
detrás de estos algoritmos. En esta lección,
intentamos visualizar los estados de algunos de los algoritmos
muy básicos. Aún no hemos escrito
ningún código Python. En la siguiente lección,
vamos a escribir y ejecutar algún código real
en entorno Python. Entonces eso es todo por esta lección.
3. Algoritmo de partición: Hola a todos. En esta lección, aprenderemos sobre el particionamiento. Entonces, ¿qué es el particionamiento de Ellie? Expliquemos con un ejemplo. Tomemos una LEA con
los siguientes números. Eso es 387-272-1402
particionar esta matriz, tenemos que elegir primero un número
especial llamado pivote, que es uno de los números
presentes en la matriz. Digamos, elegimos cuatro
como número de pivote. Tenemos que reorganizar los
números en la matriz. Para que después de reorganizar todos los números a
la izquierda del pivote, o menores o iguales
que el valor del pivote. Y todos los números
a la derecha
del pivote son mayores
o iguales que el valor del pivote. Si tomamos por SDP vert, entonces una posible solución podría
ser la que se muestra en la pantalla. La solución es 032-14-7078. Tenga en cuenta que los números a
la izquierda del pivote por
menos de igual a cuatro. Números a la derecha de
cuatro, iguales a cuatro. La submatriz izquierda y las patas no están necesariamente
ordenadas por sí mismas. También tenga en cuenta que si hubiéramos
ordenado toda la matriz, entonces después de particionar,
la posición, el pivote obtiene
la misma que la posición que
obtendría después de ordenar toda
la matriz. Extraer para desarrollar un algoritmo para particionar esta dada LA. Pasemos por el
algoritmo paso a paso. Primero, necesitamos colocar el pivote en la primera
ubicación de esta matriz. Entonces necesitamos
tomar dos punteros, P1 y P2, y hacerlos apuntar a los
dos primeros elementos respectivamente. Entonces p1 apunta
al primer elemento y v2
apunta al segundo elemento. Entonces necesitamos mover P2 paso a paso
hasta el final de esta LA. Y mientras movemos esto, en cada paso,
necesitamos hacer algo
llamado check and swap. Entonces, ¿qué tenemos que
hacer de la siguiente manera? En cada posición de P2, necesitamos verificar si el valor en p2 es menor o
igual que el pivote. Si no, entonces no hagas nada. Pero si es así, entonces necesitamos incrementar el
otro puntero p1 en
un paso y luego intercambiar
los valores de P1 y P2 se detendrán cuando P2 llegue
al final de la matriz. Vamos a llevar a cabo los pasos. Por lo que actualmente P2 se encuentra en la posición dos y
su valor es ocho. Entonces P2 no es
menor que b trabajado para. Entonces ambos se deben por un solo paso. Por lo que 77 vuelve a ser no
menos que igual a cuatro. Entonces movemos P2 por un paso. Ahora, dos es
menor que el pivote para. Entonces tenemos que hacer
este sub paso aquí. Entonces, lo que tenemos que hacer ahora
es mover p1 un paso adelante y luego intercambiar los valores de P1 y P2. Entonces otra vez mueve P2 por un paso. Y nuevamente, vemos
que el valor en P2, que está activado, es
menor o igual a cuatro. Entonces tenemos que volver a
hacer este paso de swap, que es primero morph
P1 por un paso. Y luego intercambiar los
valores de P1 y P2. Nuevamente mueve P2 por un paso. Y nuevamente, observamos
que el valor en P2, que es tres, es
menor o igual a cuatro. Entonces volvemos a mover p1 por un
paso y luego hacemos el swap. Más 321 paso. Y vemos que cero vuelve a ser
menor que igual a cuatro. Entonces nos movemos uno por un paso
y luego hacemos el swap. En este punto, P2 está
al final de esta matriz. Por lo que el bucle sobre P2 ha terminado. Ahora, como último paso, necesitamos intercambiar la primera
ubicación de la matriz, que es el valor pivote con p1. Esto colocará el pivote en
su ubicación ordenada correcta. Y ahora vemos que todos los números a la izquierda de pivote o menos que
iguales a cuatro. Y todos los números
a la derecha del pivote mayores que iguales
al valor de pivote para. Esta es una
partición válida de la matriz. Espero que esto haya ayudado
a visualizar los pasos internos a la hora de
aprender el algoritmo. A continuación, revisaremos
el código Python para este algoritmo de partición. Aquí hay una función de Python
llamada partición, que toma una entrada llamada a, que es Danny, y divide con
respecto a un pivote. Y esto supone que el pivote se ubica en la primera
posición de esta matriz. Pasemos por este
algoritmo línea por línea. Primero inicializar
los dos punteros, p1 y p2 a 0.1 respectivamente. Luego establecemos el pivote leyendo la primera ubicación de la
matriz que es un cero. Entonces, como mencionamos anteriormente, nos gusta mirar por encima de P2. Entonces P2 se mueve desde su ubicación actual hasta
el final de la matriz. El final de la matriz se
denota por la longitud de la matriz. Entonces la siguiente declaración if, implementamos la lógica
que discutimos anteriormente. Es decir, si a de p2 es
menor que igual a pivot, entonces movemos p1 y luego intercambiamos
los valores de P1 y P2. Esta línea AFP una
coma f p2 es igual a una f B2 coma f de p1 es la expresión Python
para intercambiar dos valores. Aquí los valores son
a de P1 y P2. Entonces esta es una sintaxis muy
intuitiva. Y luego comenzar
esta sentencia if, seguimos moviendo P2, bueno, un paso en cada
iteración de este bucle while. Y cuando salen
del bucle while, es decir, eso significa
que cuando P2 llega
al final de la matriz, entonces nuevamente el swap
es cero y a de P1. Esto es para llevar el pivote
desde su ubicación actual, que es el comienzo
de la matriz, hasta su ubicación final. Y eso es todo por esta lección.
4. Programa de partición de arreglos: Hola a todos. En esta lección, ejecutaremos el programa Python para la partición de
matrices. Aquí tenemos la función de partición
que ya hemos visto. También hay una función principal
que crea una lista llamada mi lista y llama a la función de partición
con mi lista como entrada. Ejecutemos el programa
en modo de depuración. Pongamos un punto de interrupción en la función
principal y ejecutemos. Entonces estamos en el punto de quiebre. Y primero vamos a crear
la lista, mi lista. Por favor, vigile la sección de estas
variables y podrá ver los valores de las variables. Y luego ingresa a la función de
partición. Primero inicializar p1 y
p2, los dos punteros. Y luego establecer el pivote, que suponemos que es el primer elemento
de la matriz de entrada. Entonces aquí el pivote es cuatro. Vamos a entrar en el bucle sobre P2. Entonces P2 se mueve desde su ubicación actual hasta
el final de la matriz. Primero, si P2 es ocho, que no es menor que
igual al periodo cuatro. Así que pasamos la sentencia if y pasamos a la siguiente
iteración del bucle. Ahora, si P2 es igual a 77, que no es menor que
igual al pivote. Entonces pasamos a la
siguiente iteración. Ahora, si P2 es dos, que es menor que igual
al pivote cuatro. Entonces entramos en
la sentencia if, incrementamos más allá por
u1 y hacemos el swap. Pasamos a la siguiente iteración. Ahora AF P2 está encendido. Entonces nuevamente ingresa la
declaración if y haz el swap. En la siguiente iteración
de P2 es tres, que es menor que
igual al pivote cuatro. Entonces nuevamente, ingresamos la
declaración if y hacemos el swap. En la siguiente iteración. Si B2 es cero, que es menor que
igual a p, ¿para qué? Entonces ingresamos la declaración if
y volvemos a hacer el swap. Y ahora P2 ha llegado
al final de la matriz. Entonces salimos
del bucle while. Y luego hacemos el swap final, el valor pivote, que está en
la primera ubicación con b1. Y eso completa
el algoritmo. No en la sección de variables. Se puede ver el
estado actual de la lista de la mente. Y se ha particionado. Entonces todos los números a la izquierda de cuatro o
menos de igual a cuatro, y todos los números a la derecha de cuatro o
mayores que iguales a cuatro. Entonces, si tengo que explicar todo
el algoritmo en
un lenguaje muy sencillo, sería así. Hay dos
punteros, p1 y p2. ¿Qué es lo que realmente hacen? B1 mantiene un límite
entre las dos particiones. La partición izquierda, que es desde el principio
de la matriz hasta p1, es el conjunto de números que son menores que iguales
al valor de pivote. Y los números a
la derecha de P1 son los números que son mayores que iguales
al valor de pivote. Entonces, ¿cómo logran esto p1 y
p2? B2 explota cada nuevo
número de la matriz. Y si ese número recién
explorado es menor que igual
al valor de pivote, entonces B1 extiende
el límite izquierdo y ese nuevo número se mueve
a la partición izquierda. Por intercambio. De esta manera, la partición izquierda siempre contiene valores
menores que iguales al pivote. Y la partición derecha contiene valores que son mayores que iguales
al valor de pivote. Tenga en cuenta que la partición derecha comienza después de T1 y
se extiende hasta P2. Te sugiero que
pases por este programa en tu entorno de
programación Python. Para que los pasos internos
se vuelvan muy claros para ti. Y eso es todo por esta lección.
5. Algoritmo de búsqueda binaria: Hola a todos. En esta lección aprenderemos sobre la búsqueda binaria. Entonces, ¿qué es la búsqueda binaria? ¿Aquí? Se nos da una
matriz ordenada de números enteros, y también se nos da
otro entero único x, necesitamos encontrar la ubicación
de x en esta matriz ordenada a. si x no está presente en a, entonces podemos devolver menos uno. Tomemos un ejemplo. Se nos da la matriz ordenada a, que es, se puede ver que
ordenada en orden creciente. Y también se nos da
otro número x. Necesitamos encontrar
la ubicación de x. Si x está presente en a, de
lo contrario necesitamos
devolver menos uno. Entonces aquí podemos ver que
siete está presente en la LEA. Y la ubicación de
siete es el índice cuatro. Eso significa el quinto lugar. Entonces tenemos que devolver cuatro. En este caso. Si el valor de x es, entonces podemos ver que nueve
no está presente en la a. por lo que la búsqueda binaria
debería devolver menos uno. Intentemos visualizar el algoritmo de búsqueda
binaria. Se nos da la matriz ordenada, que se ordena en orden
creciente. Y necesitamos buscar
un número X dado en a. aquí, el valor de x es siete, así que necesitamos buscar siete. En una primera, tenga en cuenta
que podemos recorrer toda
la matriz un elemento
a la vez y buscar x Esto tomará n pasos, donde n es el número total
de elementos en la matriz. Si la matriz es demasiado larga, entonces el tiempo requerido para buscar de esta manera también
será muy largo. Entonces esta no es una forma eficiente. Si la matriz no fue ordenada, entonces tendremos que
hacerlo de esta manera. Pero ahora mismo la
matriz está ordenada. Entonces necesitamos usar esa propiedad para acelerar nuestro algoritmo. Escribamos el algoritmo
en un lenguaje sencillo. Primero, necesitamos establecer dos puntos al inicio
y al final de la matriz. Digamos el LPS
y p. dijimos que P está al inicio
y p al final. A continuación, encontramos el
punto medio de P S&P que significa que encontramos P S más p todos divididos por dos
y redondeados por debajo. Entonces a esto se le llama el punto medio. Tenga en cuenta que esto se
deja sesgado hecho. Eso significa que P S seguro es
dos y p es tres. Entonces mate es dos más 3/2. Y esta división es
una división entera. Entonces el resultado es dos. punto medio de 2.3 es dos, los puntos
medios de 23.4 es tres. punto medio de 234.5 es tres. Por eso se le llama hecho sesgado
a la izquierda. Calculemos la
mitad de la corriente P S&P. P S es cero y P es
70 más siete por dos, que es 3.5. Redondeado. Hola es tres es igual a tres. Así que el medio se coloca en el índice tres. Ahora, estamos buscando x. Entonces comparamos el
valor a mí con x.
Si x es igual a mate lo
que has encontrado
la ubicación de x, y devolvemos el valor de la carne. Si no, entonces x está ya sea a la derecha de la carne
o a la izquierda de la carne. Si x es mayor que la carne, entonces x está a la derecha de la carne. Y en ese caso, podemos bordear lo que
está a la izquierda de carne para que podamos descartar toda
la submatriz,
el encuentro de desvíos. De esta manera, podemos reducir el espacio
de búsqueda muy rápidamente. Así que en cada iteración, la
mitad de la matriz total
puede ser descartada. Y eso hace que esta búsqueda
binaria sea muy rápida. Ahora, x es mayor que tres. Entonces nos movemos PS. Conoce más uno. Eso significa el justo a la
derecha de lo anterior realizado. Ahora sabemos que lo que queda a la izquierda de los compañeros
puede ser descartado. Hemos reducido a la mitad nuestro espacio de
búsqueda. Ahora. Otra vez, calculame. Por lo que actualmente PACs cuatro y p es siete. Entonces la carne de 4.7 es 5.5. Redondeado abajo es cinco. Entonces, vamos a reunirnos a las cinco. Ahora el valor de valor en
carne es 88 no es igual a x Y vemos que ahora
x es menor que mate. Entonces movemos B para hacer menos uno. Ahora, en la siguiente iteración, nuevamente, calculamos mid. Entonces verás ya que los PA
y PE tienen el mismo valor, el valor de la carne
también será el mismo. Entonces nuevamente, señalaremos
la misma ubicación. Ahora. X es igual a cumplir encontrado x. Y volvimos, hechos. De esta manera. Podemos encontrar la ubicación
de x en los datos ordenados. Ahora tomemos otro ejemplo donde x no está
presente en la LA, digamos x igual a nueve. Nuevamente, comenzamos con
PAS al inicio. Y al final. El medio apunta al punto medio. Comparamos el valor at, que es tres
con x, x es nueve. Entonces x debe estar a
la derecha de la carne. Entonces movemos VS para cumplir con más uno. Y nuevamente, calculamos,
que está aquí. Comparamos el valor x con x. El valor de x es nueve, por lo que nueve es mayor que ocho. Entonces x debe ser la luz de la carne. Por lo que movemos PA a mediados más uno. Ahora calculamos reunirse de nuevo, que es, que
será igual que bs. Comparamos x con Nate y
encontramos que x es
menor que carne ahora. Entonces movemos B a mediados menos uno. Y en esta etapa,
fíjense que P S&P se
cruzan entre sí. Entonces nos detenemos y regresamos menos uno. Eso significa que X en este caso no
está presente en
esta matriz ordenada. Veamos el código Python
para la función de búsqueda binaria. La función toma
dos argumentos. El primero es el array, es un array de enteros
ordenados en orden creciente. Y x es otro entero. Necesitamos encontrar la
ubicación de x dentro de a. y si x no está presente, entonces volvemos menos uno. Pasemos por la
función línea por línea. Primero inicializamos P, S&P, los punteros de inicio y fin. Entonces p es, se inicializa a cero, o el índice de la ubicación
más a la izquierda. Y PE es igual a la
longitud de un menos uno. Ese es el índice de
la ubicación más a la derecha. Entonces iniciamos el bucle
while con la condición P S es
menor que igual a p. Eso significa que continuamos
con el bucle while. Los dos punteros
no se cruzan entre sí. Primero, calculamos el mate, que como explicamos antes, es el encuentro sesgado de izquierda. Y luego verificamos si x
es igual a a de mediados. Eso significa una estimación de valor. Si a de mid es igual a x, entonces hemos encontrado x y devolvemos la ubicación
que se hace. Si no, entonces,
dependiendo de si x es mayor que a o x
es menor que la mitad hecha, descartamos la mitad de la matriz. Entonces, si x es
mayor que a de mid, descartamos la mitad izquierda de la matriz y el valor en sí. Eso significa que nos fijamos
a mediados más uno. Si x es menor que m es. Luego descartamos la parte
derecha de la matriz y establecemos p a mid menos uno. Y luego otra vez, calculamos mate con estas
ubicaciones actualizadas de P S&P. y repetimos de esta manera. Entonces, en cada iteración, descartamos la mitad de la matriz. Entonces, al final, pueden pasar dos
cosas. O bien se encuentra X
y en ese caso, devolvemos la
ubicación correspondiente de X o X no se encuentra. Y P, S&P se cruzan entre sí. Y salimos de
este bucle while y volvemos menos
uno. En ese caso. Espero que tengas la idea básica cómo funciona este
algoritmo de búsqueda binaria. Eso es todo por esta lección.
6. Programa de búsqueda binaria: Hola a todos. En esta lección, aprendes el programa Python
para la búsqueda binaria. Aquí está la función de
búsqueda binaria, que ya has visto. Además, hemos escrito una función principal que
llama a la búsqueda binaria. Entonces pongamos un punto de interrupción en la función principal y ejecutemos. Entonces estamos en el punto de quiebre. Entonces primero, creamos una matriz que ya está
ordenada. Como se puede ver. Por favor, vigile la sección de
variables donde puede ver los
valores actuales de las variables. Definimos x a siete. Y luego llamamos función de búsqueda
binaria
con a y x como entradas. Queremos encontrar la
ubicación de X en a. así que vamos a introducir la función de búsqueda
binaria. Primero, P, S&P Los punteros inicio y final inicializaron a 0.7 respectivamente, como verás en la sección de
variables. Luego ingresamos al bucle while con la condición P
es menor que igual a p. Luego calculamos el
valor medio de media es tres. Y luego verificamos si x
es igual o menor que, igual o menor o
mayor que la carne. Tenga en cuenta que cuando
comparamos x con carne, lo que realmente queremos decir es el
valor en el punto a de mid, si es igual a cumplirlo y ya lo
hemos encontrado, y la función regresa. Pero si no, entonces se restablece. O p es RPE dependiendo si x es
mayor o menor que. A ver. Entonces aquí el valor
de x es siete como sabemos, y a de mediados es tres. Entonces x no es igual a x
es mayor a la mitad. Entonces restablecemos el puntero
ps para hacer más uno. Este paso, descarta la mitad de eso. Así que sube a la siguiente iteración. Con los nuevos valores de P S&P El nuevo valor de P, S
es cuatro y p es siete. Así que ahora estamos
mirando el sub array, comenzando en la ubicación de la falla y hasta esta cierta ubicación, calculamos reunirse de nuevo. El valor de la carne es ahora
cinco es igual a ocho. Por lo que actualmente es
menos de una de mediados. Entonces viene aquí. Y ahora establecemos p0
a mediados menos uno. Ahora mira las
variables sección P, BE y PA tienen el mismo
valor, que es cuatro. Entonces el punto a la misma
ubicación en la matriz. Calculamos mediados. Mid también
es para obviamente. Entonces ahora x es igual a f cumplir. Y volvemos a mediados, que es el valor cuatro. Así que hemos regresado de la función de búsqueda binaria
y el resultado es cuatro. Eso significa que X está presente en índice cuatro de la matriz ordenada. Cambiemos X, 7-9. Y luego otra vez paso
a través de este programa. Tenemos la misma LEA, que ya está ordenada. Ponemos x a nueve y luego
ingresamos la búsqueda binaria. Entonces P, S&P se inicializan. Inicia el bucle. El valor de la carne
inicialmente es tres. Entonces x no es igual a
x es mayor que m, Es un bs más uno. Y continuar a la
siguiente iteración. Y ahora MIT es cinco. Entonces AF made no es igual
a x, es menor que x Así que restablecemos ahora
ps para
ponernos guantes y pasar a la siguiente iteración. Calcular reunirse de
nuevo, que es seis. Entonces AF tomó su decisión ahora, que no es igual a x. No, x es menor que a de media. Ciertamente ven aquí y
haz un reset p menos uno. Ahora bien, observe que el valor de P, S es seis y el
valor de B es cinco. Eso significa que P, S&P se han
cruzado entre sí. Aquí, el bucle while se rompe
y volvemos menos uno. Entonces verás que el
resultado es menos uno. En este caso, el valor de x no se encuentra en
la matriz ordenada, por lo que devuelve menos uno. Te sugiero que
pases por esta función de búsqueda binaria en tu
entorno de desarrollo Python para que te
familiarices con los pasos internos. Y llamar a esta función con diferentes matrices ordenadas
que tengan diferentes longitudes. Y así familiarizarse con el funcionamiento interno
de este algoritmo. Eso es todo por esta lección.