JAVA PARA TODO EL MUNDO: estructura de datos | Hadi Youness | Skillshare
Menú
Buscar

Velocidad de reproducción


  • 0.5x
  • 1x (Normal)
  • 1.25x
  • 1.5x
  • 2x

JAVA PARA TODO EL MUNDO: estructura de datos

teacher avatar Hadi Youness, Computer Engineer

Ve esta clase y miles más

Obtenga acceso ilimitado a todas las clases
Clases enseñadas por líderes de la industria y profesionales activos
Los temas incluyen ilustración, diseño, fotografía y más

Ve esta clase y miles más

Obtenga acceso ilimitado a todas las clases
Clases enseñadas por líderes de la industria y profesionales activos
Los temas incluyen ilustración, diseño, fotografía y más

Lecciones en esta clase

    • 1.

      Introducción

      1:06

    • 2.

      Estructura de datos

      1:10

    • 3.

      Pila basada en arsenales

      14:55

    • 4.

      Aplicación de apilamiento

      5:53

    • 5.

      Problema de combinación de símbolos

      13:38

    • 6.

      Problema de combinación de símbolos

      6:25

    • 7.

      Problema secreto

      8:10

    • 8.

      Colas basadas en arsenales

      4:03

    • 9.

      Colas basadas en arsenales

      9:45

    • 10.

      Aplicación de cola

      3:50

    • 11.

      Problema de Josephus

      9:33

    • 12.

      Lista vinculada única parte 1

      8:19

    • 13.

      Lista solo vinculada parte 2

      8:43

    • 14.

      Lista solo vinculada parte 3

      9:39

    • 15.

      Solicitud de lista vinculada

      3:19

    • 16.

      Pila basada en SLL

      10:26

    • 17.

      Lista doble parte 1

      7:33

    • 18.

      Lista doble parte 2

      7:07

    • 19.

      Lista doble parte 3

      6:54

    • 20.

      Lista doble parte 4

      10:06

    • 21.

      Lista doblemente vinculada parte 5

      10:02

    • 22.

      Lista doblemente vinculada parte 6

      5:57

    • 23.

      Ordenar por inserción

      10:50

    • 24.

      Selección

      9:38

    • 25.

      Tipo de burbujas

      5:52

    • 26.

      Ordenar por fusión

      13:58

    • 27.

      Ordenar rápido

      11:21

    • 28.

      Saltar búsqueda

      10:09

    • 29.

      Búsqueda de interpolaciones

      6:54

    • 30.

      Búsqueda exponencial

      7:39

    • 31.

      Project

      1:09

    • 32.

      Recapitulación

      0:46

  • --
  • Nivel principiante
  • Nivel intermedio
  • Nivel avanzado
  • Todos los niveles

Generado por la comunidad

El nivel se determina según la opinión de la mayoría de los estudiantes que han dejado reseñas en esta clase. La recomendación del profesor o de la profesora se muestra hasta que se recopilen al menos 5 reseñas de estudiantes.

226

Estudiantes

--

Proyectos

Acerca de esta clase

Esta clase te presentará estructuras de datos.

Aprenderá sobre los diferentes tipos de estructuras de datos, así como cuándo usar cada una.

Comenzaremos con pilas y colas. Usaremos una matriz para implementarlos, y luego vamos a pasar a una lista vinculada, tanto individual como doblemente.

Finalmente, discutiremos en detalles sobre la búsqueda y clasificación de algoritmos, introduciendo algunas de las técnicas y algoritmos más populares y aprenderán cuándo y cómo usarlos.

Conoce a tu profesor(a)

Teacher Profile Image

Hadi Youness

Computer Engineer

Profesor(a)

Hello, I'm Hadi. I am studying Computer Engineering at the Lebanese American University (LAU). I like to share my knowledge with everybody and I believe that teaching is a perfect way to understand anything since you must be well informed about something to be able to teach it in the simplest possible ways!

Ver perfil completo

Habilidades relacionadas

Desarrollo Más Desarrollo Ciencia de datos
Level: Intermediate

Valoración de la clase

¿Se cumplieron las expectativas?
    ¡Superadas!
  • 0%
  • 0%
  • Un poco
  • 0%
  • No realmente
  • 0%

¿Por qué unirse a Skillshare?

Mira las galardonadas Skillshare Originals

Cada clase tiene lecciones cortas y proyectos prácticos

Tu membresía apoya a los profesores de Skillshare

Aprende desde cualquier lugar

Ve clases sobre la marcha con la aplicación de Skillshare. Progresa en línea o descarga las clases para verlas en el avión, el metro o donde sea que aprendas mejor.

Transcripciones

1. Introducción: Hola y bienvenidos a una nueva clase. Ya hemos cubierto los conceptos básicos de Java y programación en general. Y en esta clase hablamos de estructura de datos. Entonces, en primer lugar, definimos una estructura de datos. Qué tipos de estructura de datos tenemos en la programación, cómo crearlos y utilizarlos. Y se centrará en estructuras de datos lineales como pilas, colas, y LinkedList. Y ya hablamos de matrices y las usamos en las clases anteriores. Por lo que estaríamos centrándonos principalmente en stack cuz LinkedList. Entonces en la pila, vamos a aprender a crear una estadística nosotros mismos y cómo usar la pila Java incorporada, cómo usar la pila basada en listas enlazadas. Entonces seguiremos con una cola. Hacemos lo mismo con la cola. Y luego finalmente crea nuestra lista individual y doblemente vinculada para verte en el siguiente video. 2. Estructura de datos: En este video, vamos a hablar de estructuras de datos. Y la estructura de datos es un formato especializado para organizar, procesar , recuperar y almacenar datos, donde existen varios tipos estructurales básicos y avanzados. Cualquier estructura de datos está diseñada para organizar los datos de manera que se adapten a propósito específico para que puedan ser accedidas y trabajadas con una manera adecuada. Como se puede ver aquí, tenemos dos tipos de estructura de datos. Tenemos lo lineal y lo no lineal. Por ejemplo, array es un, es un ejemplo de una estructura de datos lineal, y lo hemos usado tantas veces en las clases anteriores. También tenemos listas de pila y enlazadas. En el LinkedList tenemos listas singly y doblemente enlazadas. Y el tipo no lineal, tenemos gráficas y árboles. Entonces en esta clase, vamos a aprender cómo y cuándo debemos usar cada uno de ellos. ¿ Y cómo nos pueden ayudar? ¿ Y cuáles son las ventajas? Para verte en el siguiente video. 3. Stack basado en el: Un stack es una estructura de datos lineal que sigue un orden particular en el que se realizan las operaciones. Hay muchos ejemplos de la vida real de una pila. Por ejemplo, las jugadas que se apilan una sobre la otra para que se actualice, que está en la parte superior, es la primera en ser eliminada. Y la placa que se ha colocado en la posición más baja, permanece en la pila por el periodo más largo de tiempo. Aquí, por ejemplo, tenemos nuestra pila vacía y empujamos, por ejemplo, el número uno, y luego lo empujamos en el número dos y luego tres. Por lo que tenemos 123. Ahora bien, si queremos sacar un elemento, tomaremos tres, que es el último elemento, el ingresado. Por lo que se puede ver simplemente para seguir el orden lifo que es último en entrar, primero en salir. Entonces aquí tenemos dos operaciones principales, el push y el pop. Ahora tenemos una clase de pila en Java, pero no la usamos en este video. Simplemente implementaremos los métodos nosotros mismos. Y para implementar la pila, usamos una matriz. Así que sigamos adelante y usemos array para implementar nuestra pila. Sigamos adelante y creemos un nuevo proyecto. Démosle un nombre. Y este nombre del paquete como una fase. Y, y este paquete va a crear fuera. Entonces esta es nuestra pila de matriz de clase. Y Vamos a crear una interfaz y nombrarla pila. Entonces aquí tenemos interfaz, y aquí tendremos todos los métodos. Entonces esta es nuestra interfaz. Y así en primer lugar, tenemos, como usted dijo, el método push y pop. Entonces habrá empuje del vacío público, y estaremos empujando un objeto. Podría ser enteros, cadena, carácter, y así sucesivamente. Y otro método que es y hacer estallar un objeto. Y vamos a crear algunos otros métodos. Entonces en lugar de estallar, hacer estallar un elemento, y cuando hacemos estallar un elemento, lo movemos de la pila. No obstante, si nosotros, sólo queremos echar un vistazo a este elemento, necesitamos crear otro método y lo nombraremos. Por lo que sólo echamos un vistazo a este objeto usando ese método superior. Y sigamos adelante y creemos algún otro método. Por ejemplo, el tamaño para comprobar el tamaño de la pila y el SMD. Está vacío. Y para comprobar si la pila está vacía o no, devolverá un verdadero booleano si está vacía y falsa de lo contrario. Entonces aquí tenemos nuestros métodos. Ahora. Tenemos algún problema aquí. Porque siempre que queremos empujar y reutilizar matriz, así que si queremos empujar, la matriz está llena, tenemos un límite en la matriz. Y por ejemplo, digamos que el área es de talla cuatro. Y ya estamos empujados por elementos. Y tratamos de empujar el quinto. Entonces tendremos un promedio aquí. Ya que la matriz es limitada y no podemos empujar cinco elementos en un elemento de cuatro a. y por supuesto, si quieres hacer pop un elemento y la pila está vacía, entonces no tendrá, no va a tener ningún elemento que pop para ver desde la parte superior método. Entonces, para arreglar eso, necesitamos crear nuestra propia clase de excepción. Entonces sigamos adelante y creemos nuestra excepción. Vamos a nombrarlo excepción de pila. Y como de costumbre, solo crearemos nuestra excepción pública constructor. Y tomaremos mensaje de cuerda y tiraremos de la cena. Y por supuesto vamos a lanzar extender, lo siento, la clase de excepción para usarla en esta clase. Entonces ahora terminamos con esta excepción de Stark. Volvamos atrás y necesitamos lanzar esta estática esa excepción. Por lo que arroja la excepción. Y lo mismo. Otros métodos que la excepción. Y ahora estos son nuestro método. Entonces aquí tenemos un error arroja. Ahora volvamos a la clase de pila basada en matriz e implementemos este método creado anteriormente aquí. Entonces, en primer lugar, necesitamos extender o implementar la interfaz de pila. Porque cada vez que queremos usar una interfaz, necesitamos agregar aquí implementos y vamos a implementar la interfaz de pila. Y por supuesto tenemos un error diciendo que hemos heredado métodos abstractos y que necesitamos implementar. Entonces vamos y cada método, y estos son nuestros métodos. Entonces empecemos con lo primero de todo, necesitamos crear el constructor, por supuesto. Así que en primer lugar, tenemos hoy, y podría ser una cadena entera, carácter, doble cualquier cosa. Entonces le daremos el valor del objeto y démosle el nombre. Y por supuesto tenemos nuestro entero menos de m. Y así sería aquí donde vamos a movernos. Ahora, vamos a crear nuestro constructor. Y el constructor de la base. Entonces este es el constructor y tomará la capacidad de la matriz o la pila si lo desea. Y por supuesto, vamos a instanciar el objeto a una con el valor de la capacidad. Y aún tenemos top. Entonces al principio, digamos que el tau es igual a minús1, y veremos por qué en un minuto. Entonces top es igual a minús1, y aquí tenemos público. Entonces este es nuestro constructor. Ahora vamos a nuestro método es vacío. Entonces si por ejemplo, si top es igual a minús1, devuelve true, eso está vacío, de lo contrario, devuelve false. Entonces si top es igual a menos uno, está en la condición inicial o no tenemos nada y la pila simplemente devuelve true, de lo contrario devuelve false. Ahora, tenemos un atajo a esto. Entonces, en lugar de decir volver, de lo contrario, regresar, simplemente podemos decir que el retorno es igual a menos uno. Por lo que esta afirmación, top es igual a menos uno. Se comprobará si top es igual a minús1 devolverá automáticamente un booleano. Y devolver aquí un booleano resultaría en devolver un método booleano. Entonces si la parte superior es igual a menos uno , devolverá verdadero. De lo contrario devolverá falso. Ahora, todavía tenemos el tamaño que es fácil. Por lo que el año simplemente devolverá lo que tenemos aquí, un top más uno. Entonces al principio tenemos top es igual a menos uno. Entonces siempre que necesitemos saber el tamaño, solo agregamos uno a la parte superior. Entonces aquí tenemos menos uno más uno igual a 0. Por lo que la condición inicial de la pila es de tamaño 0. Ahora, vamos a nuestro método de empuje. Entonces tenemos nuestro arbusto. Y aquí, en primer lugar, necesitamos comprobar si la pila está llena, entonces no podemos agregar otros elementos. Entonces, en primer lugar, necesitamos establecer el tamaño. Es igual a la array.length. Entonces siempre que tengamos el tamaño que es top plus uno es igual a array.length de lo que necesitamos lanzar nuestra excepción aquí. Lanza una excepción. Esa excepción con un mensaje de método. Dice que SQL. Ahora bien, si este no es el caso, entonces seguiremos con normalidad. Entonces lo que vamos a hacer es primero incrementar, ya que agregamos un elemento configurado, ya no minús1, es igual a más uno, que es igual a 0. Entonces ahora si queremos usar la talla, obtenemos top plus 10 más 11. Y así es cuántos elementos tenemos en la pila en este momento si usamos el método push. Entonces ahora después de aumentar la parte superior, necesitamos escuchar la matriz al valor del objeto que ingresamos aquí. Y ahora terminamos con nuestro método de empuje. Vayamos a nuestro muelle. Aquí. En primer lugar, necesitamos comprobar si nuestra pila está vacía, entonces no tenemos ningún elemento que mostrar. Si está vacío. Entonces lanza esa excepción. Excepción y diciendo que la pila está vacía. Ahora bien, si este no es el caso, entonces nuestro elemento sólo tiene que añadir la copa índice. Ahora vamos a nuestro método final. Y el método que necesitamos para comprobar si está vacío. Si la pila está vacía, necesitamos lanzar la excepción, diciendo eso. Y de lo contrario, necesitamos devolver este objeto. Lo que sea que tengamos en la parte superior. Aquí. Por ejemplo, si usamos pop aquí, entonces necesitamos devolver este objeto y moverlo de la pila. No obstante, si usas stop, entonces solo echaremos un vistazo a este objeto que es igual a tres sin quitarlo de la pila. Entonces volvamos atrás. Y aquí, en primer lugar, vamos a crear un objeto ClassName y volver. Entonces este es el objeto que vamos a devolver, y lo es. Ahora iniciamos el objeto aquí y esta variable para volver. Y necesitamos eliminar este elemento, por lo que simplemente le damos un valor de nulo. Y ahora no lo hacemos, quitamos un elemento, por lo que necesitamos disminuir eso. Entonces, por ejemplo, si tenemos tres elementos y utilizamos el método pop, entonces disminuirá nuestra variable top de tres a dos a uno. Por lo que simplemente disminuiremos por un máximo menos menos y devolvemos este objeto y esta variable aquí. Entonces lo que obtenemos aquí es que creamos nuestra interfaz, nuestra excepción, y nuestra clase, que tenemos, todos nuestros métodos. Por lo que en el siguiente video, crearemos nuestra clase de conductor y usaremos estos métodos en ella. 4. Aplicación de la Stack: Entonces ahora que tenemos todos nuestros métodos, vamos a crear nuestra clase de conductor. Entonces el, este es nuestro conductor. Y yo lo haría método principal. Por supuesto que vas a lanzar una excepción de pila. O podemos decir excepciones, ya que la excepción de pila es una subclase de la clase de excepción. Y en primer lugar, necesitamos crear nuestro nombre en una pila base S en su lugar, una pila con una capacidad de puerto, por ejemplo. Ahora, lo primero que vamos a hacer es agregar un elemento a este aquello, así que usamos la pila, el Bush. Vamos a añadir otro y apilar el push para apilar los tres. Entonces vamos a hacer como este ejemplo. Entonces, en primer lugar, tenemos una pila vacía. Después empujamos tres elementos. Ahora, ¿qué? Va a suceder aquí, cuando ejecutemos este código, vayamos a nuestra pila basada en matanzas. Vamos a usar este método tres veces. Por lo que en primer lugar, tenemos la parte superior inicialmente es igual a menos uno. Cuando empujamos al número uno. Lo que está pasando aquí es, en primer lugar, debería estar comprobando que el tamaño de este tamaño es igual a array.length. Ahora la array.length es la capacidad aquí. Por lo que esta capacidad y la clase de conductor aquí es la array.length. Ahora, el array.length aquí es igual a cuatro. Por lo que es un PE, ya que el tamaño es igual a más uno y top es igual a minús1. Y inicialmente así tamaño igual a 0 ya que no tenemos ningún elemento y 0 no es igual a cuatro. Entonces no vamos a lanzar la excepción de pila. Entonces ahora vamos a aumentar la parte superior. Ahora DOB es igual a 0. Y en este caso vamos a añadir este elemento, que es uno. Lo vamos a sumar al at a, en la posición 0, ya que aquí lo incrementamos. Ahora, lo mismo. Vamos a hacer lo mismo dos veces más para el objeto 23, para enteros 23. Entonces, y vamos a comprobar si talla. Ahora el tamaño es igual a uno. Dado que el tamaño es igual a más uno y top es igual a 0. Por lo que el tamaño es igual a 0 más uno. Y por supuesto que no es igual a cuatro, no es igual a la longitud. Entonces la pila aún no está llena, y la incrementamos una vez más y la almacenaremos en, en una posición uno, luego tú elemento y luego en posición de matriz al segundo, el tercer elemento. Entonces aquí déjame revisar aquí los lados. Por lo que imprimimos tamaño de pila. Y después de sumar, este elemento irá. Vamos a revisar la talla, talla. Y por último, lo vamos a revisar después de agregar el tercer elemento. Entonces sigamos adelante y ejecutemos este código. A ver qué va a pasar. Por lo que en primer lugar, tenemos este tamaño igual a 123. Y déjame usar la pila es el método vacío. Por lo que aquí la pila está vacía, debería devolver verdadera. Por lo que la pila está vacía. Ahora bien, si lo usamos, por ejemplo, aquí, la pila está vacía. Debe devolverse falso. Dado que la pila no está vacía, tenemos tres elementos en la pila. Ahora, también tenemos la pila, la parte superior. Aquí. Tenemos tres elementos. Entonces si usamos la pila la parte superior, nos dará este valor sin quitarlo. Entonces, usémoslo aquí. Decimos elemento superior. De esta manera esos datos. Y vamos a ejecutar el código que nos va a dar el elemento superior es igual a tres. Ahora usemos el pop, pop, y también nos dará tres. No obstante, si usamos la pila, el método top, nuevo aquí, ahora que quitamos el elemento tres no obtendría tres. Tendremos dos ahora, ya que movemos este elemento, ahora, el nuevo elemento en la posición superior es el elemento dos. Entonces estos son todos los métodos que implementamos en la clase de pila basada en matanzas y la interfaz por supuesto. Entonces esto es todo para este video. Nos vemos en el siguiente. 5. Problema de igualación de símbolos: Vamos a demostrar el uso de la pila. Entonces haremos un ejemplo. Consideremos esta etiqueta. Entonces aquí tenemos nuestra pila, y hagamos un ejemplo sobre la coincidencia de símbolos. Por lo que nuestro programa debe devolver ya sea que la expresión sea válida o no. Entonces, por ejemplo, estos son los símbolos de apertura, y estos son los símbolos de cierre. Ahora, déjame escribir de esta manera. Entonces aquí tenemos nuestros tres símbolos. Y permítanme escribir aquí algunos ejemplos. Por ejemplo, si decimos etch. Por lo que nuestro programa debería volver verdadero aquí, ya que este símbolo de apertura tiene uno de cierre. No obstante, si nosotros, por ejemplo, digamos edge, y permítanme colocar uno aquí. Por lo que este símbolo de apertura no tiene uno de cierre antes de abrir uno nuevo. Entonces aquí tenemos esto. Y para ser una expresión válida, deberíamos agregar una aquí y usted movió esto. Ahora, cada símbolo de apertura es seguido por uno de cierre. Y por supuesto podemos agregar lo que quieras. Y así este es un sentido válido. cada símbolo de apertura le sigue un cierre. Entonces lo que vamos a hacer es aceptar una expresión y luego almacenar cada apertura, cada símbolo de apertura en la pila. Entonces supongamos que tenemos esta expresión. ¿ De acuerdo? Entonces tenemos, por ejemplo, a, B, C, y D. Déjame dar click al 20. Y así esta es nuestra expresión y pasará por esta expresión uno por o. entonces a no coincide con ninguno de estos símbolos de apertura, apertura. Entonces lo ignoraremos e iremos a este corchetes rizados. Y coincide con éste. Por lo que lo almacenamos en la pila. Entonces aquí tenemos, ahora este corchetes rizados. Entonces iremos a B. No tenemos en B no coincide con ninguno de estos, ninguno de estos símbolos, lo ignorará e irá a éste. Esta tampoco coincide con ninguna de estas aperturas, pero coincide con la de cierre. Por lo que aquí tenemos este partido mejor. Y por supuesto, vamos a reventar este elemento en la pila, compararlo con éste. Si son iguales, entonces seguiremos en nuestra expresión. De lo contrario, vamos a devolver falso. La expresión no es válida. Entonces vamos a hacer lo mismo aquí. Tenemos estas fantasías y las voy a comparar. Este. Vamos a ir a ponerlo en la pila y compararlo con ésta. Y por último, tenemos los corchetes también. Ahora podríamos tener también, por ejemplo, algo como esto. Entonces lo que va a pasar aquí es déjame, déjame borrar es. Y así esta es nuestra expresión. Y antes que nada, vamos a ver esto. Se trata de un símbolo de apertura, por lo que lo colocará aquí. Y luego vamos a mirar al segundo elemento. Tenemos corchetes. Por lo que es un símbolo de apertura también, y lo almacenaremos en la pila. Entonces lo vamos a empujar. Entonces estas fantasías bajarán aquí y los corchetes aquí. Ahora, vamos a revisar el tercer elemento, este de cierre, lo vamos a comparar con el elemento superior de la pila. Entonces aquí tenemos un corchetes de cierre y un corchetes de apertura, el partido. Entonces sólo vamos a reventar este desde aquí. Y vamos a seguir aquí. Y por supuesto vamos a poner los paréntesis aquí. Ahora, después de eso, vamos a comparar este símbolo de apertura con el último elemento aquí. Y por supuesto la imagen, entonces nuestra expresión es válida, lo contrario sería inválida. Entonces esta es una idea rápida sobre este problema, y empecemos con escribir código R. Entonces aquí tenemos nuestra pila basada en matas. Vamos a crear una nueva clase y nombre y símbolo que coincida. Y ahora clase, por supuesto, tenemos nuestro método principal y crearemos un método que devuelve un verdadero booleano si la expresión es válida, lo contrario devolverá falso. Por lo que sería un booleano estático privado. Vamos a nombrarlo, validarlo, y aceptará una expresión como forma de cadena. Ahora, antes que nada, comenzaremos con el bucle Y. Y ya veremos qué vamos a poner como condición aquí. Ahora vamos a crear nuestra pila basada en matas y con el perímetro de expresión esa longitud. Por lo que el número máximo de elementos que se pueden almacenar en la pila es el número máximo de elementos en esta cadena. Entonces si todos se están abriendo, podemos guardarlos todos. Pero claro va a devolver un inválido, falso ya que no los cerramos. Ahora, tenemos, nuestra pila ha creado, por ejemplo, un índice, el mismo índice. Será a las 0. Y es válida una declaración booleana. Bueno, en primer lugar, para ser igual a verdad y carácter, pongamos nombre a la corriente. Ahora. Si bien es válido y por qué esta expresión es válida, entonces seguiremos ejecutando este código. Y por supuesto, mientras que el índice es menor que la longitud, longitud de la expresión. Por lo que se cumplen estas condiciones. Continuar ejecutando este código. Ahora, en primer lugar, ir a almacenarlo en esta corriente, este personaje igual a la expresión en el índice. Entonces supongamos que tenemos este ejemplo y antes que nada, vamos a almacenar edge y current. Ahora vamos a comprobar si este director coincide con alguno de los símbolos de apertura o cierre. Entonces para hacer eso, déjame crear alguna apertura, algunas cuerdas para crearlas afuera. Serán privados. Terapia. Esta apertura será igual a estos símbolos de apertura. Y por supuesto, estática privada. Cierre de cadena b igual a es símbolos de cierre. Ahora, lo que vamos a hacer es comprobar si esta corriente coincide con alguno de los símbolos de apertura. Entonces si recordamos correctamente, tenemos la clase string, el índice del método apagado. Entonces, usémoslo aquí. Por lo que F subiendo el nombre que índice fuera. Entonces lo que estamos tratando de hacer aquí es comprobar si la corriente es una apertura. Entonces si abriendo ese índice de corriente, entonces si actual es uno de los caracteres en la cadena de apertura, entonces devolverá el índice de la misma. Entonces, por ejemplo, si tenemos corriente es igual a este símbolo de apertura, devuelve 0, símbolo disciplinar uno, y el último símbolo de apertura al que volvería. De lo contrario, volverá menos uno si no es igual a ninguno de estos símbolos. Entonces f adivinar. Símbolo no es igual a menos uno. Entonces simplemente lo empujaremos al estado de pila que empuje. Y vamos a empujar esta suma, pero ahora no es así. Podría ser un símbolo de cierre. Entonces lo que vamos a hacer es comprobar como cerrar ese índice. Esta corriente tampoco es igual a menos uno. Si esta corriente es uno del símbolo de cierre, entonces devolvería cualquier valor que no sea menos uno. Entonces este es el caso y la corriente es un símbolo de cierre. Entonces nosotros, luego lo vamos a comparar con uno de apertura de la pila. Entonces vamos a reventar un símbolo de apertura de la pila. Y podemos comparar fácilmente los símbolos o recuento comparar el índice. Entonces, por ejemplo, tenemos los corchetes rizados. Entonces si comparamos el índice de apertura y cierre, si son iguales, entonces los símbolos son iguales. Entonces esto es lo que vamos a hacer. Entonces si abriendo ese índice de pila, ese puck no es igual al índice de cierre de esta corriente. Y este no es el caso, entonces acabamos de regresar es válido a falso. Ahora tenemos un error aquí diciendo que el índice del método de tipo String class no acepta objeto ya que la pila que pop es un objeto. Y también sabemos que sólo estamos almacenando en este carácter de pila. Por lo que puedo decir con seguridad que sabemos que necesitamos que esto sea un personaje. Y ahora veamos excepción no manejada, ya que podríamos tener excepción aquí y este tipo de push and stack the pop. Entonces para estar del lado seguro, vamos a usar un try y catch. Entonces vamos a probar esto. De lo contrario si se produjo una excepción de pila, solo gadget y devolver false. Vamos a aumentar el índice para pasar por toda la expresión de los elementos en esta expresión. Y vamos a regresar es válido. Por lo que devolverá verdadero si la expresión es válida, lo contrario devolverá falso. Ahora todavía tenemos una modificación y lo haremos en el siguiente video. Por qué ejecutar el código para verte en el siguiente. 6. Problema de igualación de símbolos 2: Entonces veamos qué haría nuestro código hasta ahora. Por ejemplo, si tenemos esta expresión, en primer lugar, obtendrá el primer elemento y lo comparará con uno de los símbolos de apertura. Si este no es el caso, lo comparará con los de cierre. Y por supuesto, si no coincidió con ninguno de estos abriendo y cerrando, seguiremos sin hacer nada. Entonces en segundo lugar, obtendremos este símbolo de apertura en comparación con uno de los símbolos de apertura en la abertura de cuerda. Y por supuesto que coincidirá con los corchetes rizados y lo vamos a empujar a la pila. Ahora, haremos lo mismo con este D y el de un personaje. No vamos a hacer nada desde los símbolos de apertura o cierre final. Entonces tendríamos este símbolo de cierre y coincidirá con uno del símbolo de cierre y la cepa de cierre. Y si este es el caso, entonces no hacemos pop-up nada. El primer elemento, el elemento superior en la pila, es decir, este símbolo. Y lo vamos a comparar con el de cierre. Vamos a comparar el análisis de ellos y son iguales, entonces no vamos a hacer nada. Si no lo son, entonces vamos a hacerlo, voy a decir que como válido ahora es falso. Por ejemplo, si tenemos este símbolo que la pila, vamos a tener los corchetes rizados hacia abajo y los paréntesis hacia arriba. Y vamos a comparar los paréntesis con los corchetes rizados y los no iguales. Por lo que devolverá falso. Ahora todavía nos queda una modificación por hacer. Por ejemplo, supongamos que tenemos, digamos que tenemos esto, este código se ejecutaría correctamente. No obstante, supongamos que aquí tenemos corchetes. Ahora, voy a citar, empezarán todos estos personajes, todos estos símbolos y el ciervo. Y en primer lugar, va a reventar este paréntesis y lo comparará con este paréntesis de cierre ahí iguales, entonces continuará. Y el otro, ese es este corchetes rizados y compáralo con los corchetes rizados. Ahora, terminaremos con b y no vamos a hacer nada. Y nuestro código regresamos cierto ya que no tenemos ningún problema con la apertura y cierre. No obstante, todavía tenemos este corchetes y nuestra pila. Por lo que debería, deberíamos devolver falso ya. No todos los símbolos se emparejan entre sí. Entonces lo que vamos a hacer es comparar al ciervo, usar el f m está vacío. Entonces si la pila está vacía, si no está vacía, entonces es válida va a ser falsa. Ya que todavía tenemos uno o más elementos en la pila. Y esto debería devolverse falso, no cierto. Y por supuesto que vamos a regresar es válido. Ahora, veamos los últimos ejemplos. Por ejemplo, el 3.5. Este código. Tenemos un símbolo de cierre. Y por supuesto vamos a pop de la pila y abriendo una. Ahora la pila está vacía y no tenemos ningún símbolo en ella. Por lo que esto generará una excepción y lo vamos a atrapar aquí y devoluciones caídas directamente. Entonces este es nuestro código y vamos a usarlo aquí. Entonces, en primer lugar, permítanme empezar por aceptar una expresión. Utilizamos escáner. Cuando nuevo Escáner, como de costumbre. La expresión igual a escanear. El siguiente renglón. Vamos a utilizar este método de validación. Entonces si validamos, si es cierto, entonces vamos a imprimir expresión es expresión de marca válida. Y vamos a ejecutar este código. A ver que va a pasar. Por ejemplo, vamos a ingresar la expresión de retorno es válida. Ahora, supongamos que tenemos estos símbolos. Y por supuesto, son válidos ya que cada apertura va seguida de un símbolo de cierre. Y si sólo tenemos una apertura que será invitada, sólo un símbolo de cierre, claro que sería inválido. Y finalmente, si, por ejemplo tenemos los valores, los símbolos. De esta manera, no será válida aun cuando cada apertura tenga un símbolo de cierre, pero no se ordenan de la manera correcta. Por lo que devolvió un inválido. Entonces esto es todo para el emparejamiento del símbolo del grupo. Y nos vemos en el siguiente video. 7. Problema de mensaje secreto: Ahora ya tenemos una pila construida en Java. Entonces, usémoslo y trabajemos con el problema. Ese es un mensaje secreto. Entonces la idea es que vamos a recibir un mensaje secreto que reserve mensaje invertido. Entonces por ejemplo, en lugar de saludar, Eddie será o.Así que vamos a convertir esto a Hola heady usando stuck. Entonces, en primer lugar, vamos a crear nuestro método principal. Pero esto tiene un método principal y otro que es decodificar este mensaje. Pero serás estática privada. Cadena, nombrelo, decodificar y mensaje de cadena. Vamos a crear nuestra pila aquí. Entonces, en primer lugar, tenemos una pila, y la pila será una pila de caracteres. Y este nombre es igual a nu. Y por supuesto, vamos a necesitar una cuerda. Y usemos el StringBuilder. Entonces esta es una clase de cadena. String. Se trata de una clase definida en Java como nombre en SBI y B igual a U StringBuilder. Entonces en este StringBuilder, vamos a subir a nuestros personajes y eventualmente a nuestras palabras. Entonces usemos un tokenizer de cuerdas. Tan distinta clase tokenizer permitió romper una cadena en token. Entonces para instanciar el tokenizer de cuerdas, simplemente escribimos string, el colonizador. Y lo puedes encontrar en el Java que crees que clase se llama SD, instanciada con la cadena, el mensaje en sí. Ahora que estamos listos, sigamos adelante y fuimos absueltos. Por lo que dice que la estrella no puede resultar también. Por lo que simplemente puede poner pila de Java Tutor. Y aquí deberíamos regresar, lo regresamos más tarde. Por lo que en primer lugar, leería cada palabra en el tokenizer de cuerdas. Por lo que mientras el estricto organizador tenga más tokens, seguirá ejecutándose. Lo primero que vamos a hacer es crear una lista recta fuera Emite palabra. Y si esta palabra El valor que está en el tokenizer de cadena para darle como G, el siguiente token. Ahora, supongamos que primero tenemos esta expresión, donde sería ésta. Y lo vamos a leer y empujar a cada personaje en la pila. Por lo que aquí creamos un bucle for. Para i es igual a 0 hasta que i es menor que o es esa longitud simplemente empujará este carácter en la pila para que el niño. Y simplemente empujamos a todos los personajes de la pila en esta palabra a este paso. Después de empujarlos, necesitamos extraerlos usando el método pop y una planta las hacia el StringBuilder. Entonces si bien esto no está vacío, simplemente anexamos caracteres que usando la bombilla estándar. Y después de eso, después de terminar desde el bucle salvaje, simplemente anexamos este espacio en blanco. Entonces veamos qué hicimos aquí y un ejemplo. Entonces, por ejemplo, como dijimos, si lo tenemos, vamos a escribirlo. Por ejemplo. Hola, en lugar de tener un bajo va a estar sucediendo. Esto. Ahora, a primera hora, vamos a almacenar esta coma y luego O, L, L, E, y F. Así que nuestra pila se verá como y L, o. Y, y separemos esto. Entonces aquí tenemos, esta es nuestra pila. Tenemos 123456 caracteres. Ahora, después de clasificarlos en pila, necesitamos extraerlos usando el libro de estatutos. Entonces mientras bajamos, el primer paso sería entonces E, luego L, L O. Entonces vamos a conseguir e l, l Entonces si damos este insumo, eso nos devolverá este. Y esto es lo que necesitamos. Esto es lo que vamos a hacer. Tenemos que revertir la palabra de O allele edge a hola. Entonces volvamos aquí. Y simplemente después de buscar desde el bucle salvaje, simplemente devolvemos SB por dos. Ahora, volvamos a nuestro método principal. Y en este método, necesitamos tener el mensaje y el mensaje decodificado. En primer lugar, usaremos un escáner para pedirle al usuario que introduzca un mensaje. Y simplemente le pedimos al usuario que ingrese un mensaje. Y lo almacenaremos en el mensaje. Después entramos en el decodificado usando el método decodificado y lo vendimos en el mensaje de decodificación. Para descodificar nuestro mensaje. Entonces lo imprimiremos. Mensaje descodificado. E imprimir el mensaje decodificado. Adelante y ejecutemos este código. Entonces habríamos ingresado un mensaje. Por ejemplo, como dijimos, hola. Para descodificar ese mensaje, es hola, feliz. Entonces así es como usamos lo definido por el estado en Java y cómo usarlo para revertir cualquier cosa desde mensaje a números o cualquier cosa. Te queremos ver en el siguiente video. 8. Una cola basada en la: Ahora hablemos de colas. Una cola es una estructura de datos lineal que sigue un orden particular en el que se realizan las operaciones. El olor es primero en entrar, primero en salir. Un buen ejemplo de una cola es un restaurante. El que venga primero será atendido primero. La diferencia entre pilas y colas está en eliminar. Y en su lugar eliminamos el elemento más recientemente agregado, Y la cola, eliminamos el ítem el menos recientemente agregado. Por ejemplo, aquí tenemos dos posiciones frente y básicamente tenemos dos operaciones principales, enquear y dequear. Son equivalentes a empujar y estallar en pilas. Entonces cuando queremos encola y q, el elemento en posición. Y cuando queremos dequear, solo usamos la posición frontal y retiramos el elemento de la primera posición o segundos, así sucesivamente. Por lo que ahora vamos a demostrar el uso de una cola y un ejemplo. Volvamos a Eclipse. Cierra estas clases de existencias y crea un nuevo paquete. Y sname basado. Entonces en este paquete, como hicimos en este ejemplo, vamos a crear una interfaz q a q básica. Por supuesto que vamos a crear una excepción. Excepción. Vamos a renombrarlo. Entonces estas son nuestras tres clases principales. Y empecemos con nuestra interfaz. Vamos a tener los métodos, como hicimos en este ejemplo. Tenemos un azul, pero el tamaño booleano está vacío. El vacío público tomará objetos públicos para devolver un objeto y tú lo mueves. Y nombraremos un objeto negro, lo nombraremos frente. Para sólo ver el frente. Aquí tenemos un capital energético. Y como hicimos en los ejemplos anteriores, en este ejemplo, necesitamos crear nuestra excepción. Vamos a crear un mensaje constructor, codificando mensaje y extiende la excepción. Ahora, solo necesitamos lanzar estas excepciones y estos métodos excepción de cola. Y hacemos lo mismo aquí y aquí. Entonces esto es todo para Q y Q excepción. Y el siguiente video que usaremos funcionará con el goo basado en matrices y creará nuestros métodos. 9. Una cola basada en la: Ahora empecemos con el cubo basado en matriz. Como se puede ver aquí en este ejemplo, tenemos la entrada frontal de índice. Entonces, en primer lugar, necesitamos crear una matriz de nomenclatura de objetos. Y por supuesto vamos a crear un frente y tamaño. Ahora sigamos adelante y creamos nuestro constructor. Entonces como de costumbre, la capacidad, porque estamos trabajando con una matriz y necesitamos dar el, el tamaño de la longitud y crear nuestro objeto con la capacidad igual al tamaño, igual a 0, igual a 0 inicialmente. Ahora, empecemos con nuestra talla. Por supuesto que vamos a implementar y necesitamos autorizarlo en dos métodos. Entonces aquí tenemos todos los métodos y la interfaz a un lado con el tamaño simplemente devolverá el tamaño, cualquiera que sea el tamaño ya que simplemente lo devolveremos. Ahora, vacío está vacío. Simplemente regresamos si el tamaño es igual a 0. Entonces si la ciencia es igual a 0, entonces está vacía. De lo contrario, no está vacío y debería volver verdadero. Esta expresión es una expresión booleana y devuelve true si el tamaño es igual a 0, lo contrario devolverá false. Ahora, empecemos con encola. En primer lugar, necesitamos comprobar si el tamaño es igual a array.length. Entonces no nos queda ningún espacio en la sesga y tenemos que tirar la excepción. Por lo que necesitamos lanzar la excepción. Y diciendo que Q S pie. Esta es la primera condición. Ahora bien, si este no es el caso, entonces podemos agregar el elemento al sesgo. Entonces, para agregarlo, solo usaremos el año. Por lo que lo agregaremos en la parte trasera. Y ahora necesitamos que se incremente la lectura. Entonces cuando simplemente podemos decir eso, que v plus. No obstante, cuando lleguemos a un punto donde la parte trasera está en la posición seis, y añadimos un elemento aquí, entonces necesitamos aumentar el verdadero U2 estará en la posición siete. Ahora, sin embargo, si tratamos de sumar una vez más, eso nos dará una excepción. Pero si se borra uno de los elementos frontales aquí. Por ejemplo, si usamos la Q y quitamos una, entonces tenemos un espacio vacío aquí. Y no lo usamos porque eso sólo se está incrementando en uno. Por lo que necesitamos resolverlo. Tenemos que resolver este tema diciendo que siempre que esta esfera sea igual a array.length, en este caso es igual a siete. Entonces necesitamos modificarlo y darle un valor de 0 para devolver p2 aquí. Entonces para hacer eso, simplemente podemos decir que puede usar sentencia f. Y si necesitaba longitud es igual a trasera, entonces sólo le daremos a eso un valor de 0. No obstante, simplemente podemos decir que v es igual a cerveza más uno. Lo incrementamos y el resto del tiempo. Entonces lo que estamos diciendo aquí es que V es igual a d más uno. Cada vez que el real más uno es menor que esta longitud IDED, no tenemos ningún problema. Todo funcionará correctamente ya que j más un resto de array.length es el mismo. Ya que, por ejemplo, si decimos para Comandante de cinco, es 43 resto de cinco. Lo es. No obstante, si cinco, resto de cinco es 0, por lo que siempre que tengamos tres más uno es igual a array.length trasero se convertirá en 05 resto de cinco sextos, resto de seis es igual a 0. Entonces esto es todo. Y solo incrementaremos el tamaño ya que agregamos un elemento. Ahora pasemos a la cola. Y este ejemplo aquí. En primer lugar, necesitamos comprobar si el tamaño es igual a 0 o podemos usar como método vacío. Por ejemplo, si está vacío, sería simplemente la excepción de cola diciendo que en esa cola está vacía. Y entonces podemos trabajar. Ahora, en primer lugar, necesitamos crear un objeto para devolver. Entonces lo que vamos a devolver es el elemento al frente. Entonces simplemente regresamos. Y ahora tenemos que sacarlo de la cola. Entonces para hacer eso, simplemente usamos la misma una técnica que usamos para el año r1 más un resto de a una novena en adelante, vamos a entrar en un tamaño decremento ya que quitamos un elemento y sólo regresamos para volver por esto es para la decola? Todavía tenemos un último método. Y este método sólo vamos a echar un vistazo a qué, lo que tenemos al frente. Entonces, antes que nada, vamos a comprobar si está vacío. Fila. Déjame copiar esto. Y básicamente desgarro. Y por supuesto, el array devuelto al frente. No necesitamos quitar nada. Simplemente nos voltearemos para regresar. Estos son nuestros métodos. Y devuelto todavía tienen un nuevo método. Ese es un método ToString. No lo usamos en la pila, pero puedes crear una aquí e imprimir la cola cuando queramos. Entonces sigamos adelante e implementamos. Ahora bien, si queremos crear este método público, tratando de cadena, y podemos trabajar con el bucle for y pasar a través de todos los elementos en la matriz. No obstante, prefiero modificarlo cada vez que encola o dequedemos en cola. Entonces, primero que nada creemos un StringBuilder. Es como una cadena, pero podemos modificarla. Puedes agregarla cuando queramos o eliminarla de ella. Por lo que nuevamente creamos una cadena bajo esto definido en la clase java.lang. Por lo que StringBuilder sb, sb, y él lo dará, creará una instancia de ese nuevo StringBuilder. Y realmente bueno, podemos usarlo. Por lo que cada vez que ponemos en cola, podemos anexar para distinguir el SP que anexa lo que incrementamos agregamos más espacio. Y cada vez que dequeamos, podemos dequear el elemento q de aquí a solo sba dot delete de posición 0 a la longitud del objeto más uno para dar cuenta del espacio en blanco. Entonces hasta el objeto para devolver esa longitud. Para devolver el toString, en primer lugar, necesitamos convertirlo en una cadena que sea nueve más uno. Y así es como eliminamos del StringBuilder. Y por supuesto aquí simplemente regresamos sba dot dos. Y estamos bien. Entonces esto es todo para la clase de cola basada en matrices. Y en el siguiente video, crearemos la clase de conductor en la que probaremos estos métodos. 10. Aplicación de cola: Ahora que tenemos todos nuestros métodos, vamos a crear nuestra clase de transferencia. Entonces este es un chofer y discute la comida. Contamos con nuestro método principal. Necesitamos saber la excepción de cola de cola. Y vamos a crear la base enemiga, es decir U igual a U basado en matriz Q con la capacidad de. Para. Ahora, pongamos en cola algunos elementos. Entonces por ejemplo, q punto q uno. Y vamos a copiarlo cuatro veces 234. Ahora si usamos, si imprimimos Q o Q, las dos cadenas son las mismas. Obtenemos 1234. Ahora por ejemplo, vamos a dequear. Entonces, por ejemplo, si decimos, imprimámoslo para ver qué vamos a quitar. Q punto dq. Se decola el elemento frontal en el material de posición. Entonces en este caso, vamos a conseguir uno. Entonces dequeuamos estanque y si seguimos adelante y los imprimimos una vez más, obtendremos 234. Ahora, si agregamos un elemento, por ejemplo, digamos que vamos a sumar cinco. Entonces lo que vamos a conseguir si lo imprimimos ahora es 2345. Entonces esto es todo. Ahora. No se ve así en el, ya que estamos usando el StringBuilder. No obstante, este cinco está en la posición 0 Ahora en la matriz. Pero vemos, lo estamos viendo como 2345, ya que solo estamos agregando el elemento en posición derivada y lo estás moviendo desde la posición izquierda y el StringBuilder. Ahora por ejemplo, usemos algunos de los otros métodos. Por ejemplo, el tamaño de libre, para usar lados q-dot. Aquí, vamos a conseguir tres ya que sólo tenemos tres elementos. Entonces aquí tenemos tres elementos. No obstante, si lo usamos aquí, imprime el tamaño u dot size, obtenemos cuatro ya que agregamos un elemento más. Entonces aquí podemos verlo claramente es primero que nada, tenemos tres. No obstante, si lo imprimimos después de agregar el elemento cinco, obtenemos cuatro. Ahora intentemos Q que está vacío. Vamos a imprimirlo. Está vacío y vamos a conseguir falso ya que agregamos algunos elementos aquí. No obstante, podría dividirlo con eso antes de poner en cola. Entonces vamos a conseguir esto verdadero y luego falso ya que agregamos algunos elementos. Este es un ejemplo rápido de Q. Y el siguiente video vamos a hablar sobre problema de josephus y aprendimos a resolverlo. Entonces nos vemos en el siguiente video. 11. El problema de Josefo: Ahora vamos a resolver el problema de José. En primer lugar, vamos a entenderlo. Entonces para este problema, vamos a tener jugadores y un número. Por ejemplo, digamos que tenemos tres jugadores, John, Alfred, y tendencias. En este caso, digamos que tenemos el número y el número es igual a dos. Por, por ejemplo. El primero de todo, necesitamos almacenar estos nombres, la UCIN. El juego termina cuando queda una persona. Por ejemplo, cuando decimos k igual a cuatro, En primer lugar, tenemos que dequear la cola. Nosotros Deloqueamos desde aquí. Tenemos que dequear a John y añadirlo a aquí. Entonces. Entonces esta es una vez que lo realizamos cuatro veces. Por lo que todavía tenemos tres veces. Por lo que necesitamos Eliminar, Encola, Eliminar y AQ. Y así es la última vez. Por lo que ahora realizamos esta operación para todos los tiempos. Y terminamos con Alfred en la primera posición. Entonces dequeamos la cola. Ahora todavía tenemos dos nombres. Por lo que realizaremos la misma operación también cuatro veces. Entonces dQ, Cress, y lo mismo aquí. Y finalmente, la última vez con un trozo enorme y colóquelo aquí. Por lo que terminamos con cresta en la primera posición. Por lo que lo eliminamos usando el método q y terminamos con John switch. John es el ganador. Entonces esto es todo. Entonces esta es la idea de la Georgia, este problema que vamos a resolver. Vamos ahora implementados y salientes. En primer lugar, vamos a crear nuestro método más nombrelo para que tome un hospedaje en una matriz de cadenas. Y vamos a nombrarlos jugadores y un entero k. Ahora, en primer lugar, vamos a crear una cuerda y añadir un dos q igual nu en una vista base con la capacidad de los jugadores de esa longitud. Entonces cuántos jugadores tenemos solo darían el display de taco. Ahora, en primer lugar, intentémoslo. Y si algo sucede, solo atraparemos esta excepción es una excepción de cola por supuesto, y simplemente devolveremos ese salvaje, identificando al ganador. Ahora, vamos a trabajar con nuestro bloque Try. En primer lugar, necesitamos encola a todos los jugadores en el cubo. Entonces para todos, podemos decir que para el bucle for, hay esa longitud y en cola cada vez sin embargo, podemos usar otra forma afford MOOC, que es nombremos jugador. Cuatro jugadores en distintas capas, simplemente pondrían en cola esta capa. Por lo que esta es otra forma del bucle for. Podemos usarlo cuando tengamos una mancha o algo con lo que podamos trabajar como, como variable y podemos incluir en esta cola usando esto for loop. Ahora, vamos a nuestro bucle while. En tanto nuestra cola tenga más de un elemento, solo seguirá trabajando en ella. Por lo que el tamaño de la cola y es mayor que uno. Este código se ejecutaría. Entonces, antes que nada, imprimamos la cola sin modificarla. Por lo que solo imprimiría cola. Y así q. ahora usamos el bucle telefónico desde 0, del k. solo usaremos el q-dot encola, Q, la Q. Entonces lo que estamos haciendo aquí es, primero que nada, vamos a dequear, vamos a quitar un elemento del cola y luego la almacenó una vez más usando el encola. Entonces podemos decir que necesitamos objeto. Por ejemplo, igual a Q punto dQ. Acabamos de dejar en cola el elemento y después lo almacenamos. Entonces esto es lo mismo, pero simplemente puedes agregar esto al parámetro del q-dot enqueued. Ya que debido a que Enquear acepta un objeto y este du, el dq devuelve un objeto. Entonces esto es lo mismo. Ahora simplemente después de trabajar con en este for loop en cola y dequeuing por k veces. Ahora, simplemente eliminamos el último elemento, el nombre de jugador. Por lo que simplemente podemos ver decola y lo mueves de la lista y digamos que está fuera. Ahora, ya terminamos con esto. Después de realizar este while loop, todavía tenemos un jugador y él es el ganador. Entonces cuando r igual a Q dot dq y lo eliminamos de la lista, claro que tenemos un error porque este es un objeto y este ganador se cambia. Entonces, y sabes con certeza que este elemento es una cadena. Por lo que podemos darle valor de cadena. Ahora que terminamos con nuestro código acabaría de regresar por fin. Entonces simplemente aquí. Entonces esto es todo para el problema de los josephus. Vamos a crear nuestro método principal y ejecutado. Pero primero que nada creemos una cadena de matrices, así, y una cadena de nombres. Vamos a nombrarlo capas. Y esto, vamos a crear los nombres, por ejemplo, Chris y Fred y John. Entonces esta es nuestra cadena y una cadena y tenemos un entero k que twill viene a pedirle al usuario que entre. Entonces vamos a usar el escáner para escanearlo. Y preguntemos al usuario y gay y almacenamos lo que sea que el usuario ingresó y la variable k Ahora, el ganador es resolver capas y K. Así que ya que esto devuelve una cadena, podemos almacenarla en una cadena y simplemente imprimirla. Ahora, sigamos adelante y ejecutemos este código. Entonces lo que vamos a conseguir es entrar k Por ejemplo, vamos a papel de aluminio. Entonces, en primer lugar, tenemos a Chris, Alfred Chuang. Ahora realizamos k4 veces. Entonces movimos a Chris y luego a Alfred, y luego a John, y luego a Chris, y terminamos con Alfred en la primera posición. Entonces dequeamos a Alfred y Alfred está fuera. Ahora. Todavía tenemos a John y Chris. Por lo que realizamos esta operación cuatro veces. John, Chris, John y Chris, y terminamos con John en la primera posición. Y John está fuera. Por lo que todavía tenemos un elemento o un jugador, y él es el ganador. Entonces solo imprime que el ganador es Chris. Entonces esto es todo para el problema de los josephus. Nos vemos en el siguiente video. 12. Lista única lista única vinculada parte 1: Al igual que las matrices, la lista vinculada es una estructura de datos lineal. No obstante, los elementos de esta lista están vinculados mediante punteros. Cuando usamos matrices, tenemos algunas limitaciones. Por ejemplo, el tamaño de las matrices es fijo. Y cuando necesitamos insertar un nuevo elemento en la matriz, es caro porque necesitamos crear espacio para este elemento específico. Por lo que este es un ejemplo de una LinkedList. Ahora bien, estos son nodos, por lo que tenemos cuatro nodos en este ejemplo. Y cada nodo es datos y dirección. Por lo que tenemos una caja para datos donde almacenamos nuestro elemento objeto, entero, cadena, carácter, etcétera. Y tenemos otra caja para almacenar la dirección del siguiente nodo. Por lo que podemos pensar en esta dirección de un puntero. No necesitamos saber el número numérico exacto aquí, pero debe apuntar a la dirección del siguiente nodo. Por lo que la LinkedList es esta lista. Y cuando decimos de manera individual, Esto significa que los nodos están vinculados entre sí usando una dirección. Entonces no podemos retroceder del 20 al diez, sólo podemos ir del diez al 2030 y así sucesivamente. Por lo que esta es la idea de una lista singularmente vinculada. Y vayamos a nuestro espacio de trabajo Eclipse y creemos un nuevo paquete. Nombralo lista singly enlazado. Y este paquete, como de costumbre. Primero que nada creemos nuestra clase de excepción. Ahora bien, ya que esta lista es infinita, así podemos agregar lo que queramos en esta lista y no tenemos límite. Por lo tanto, vamos a nombrar esta excepción como excepción de lista vacía. Ya que no tenemos que preocuparnos si superamos los elementos es que no tenemos ningún límite. Y en esta excepción, por supuesto, vamos a extender la clase de excepción. Extiende la excepción como lo hicimos antes, y crea nuestra lista vacía de constructor, el mensaje llamado sopa con mensaje de parámetro. Entonces esta es nuestra excepción de lista vacía. Sigamos adelante y creemos otra clase. Ahora. Veamos, por ejemplo, vamos a crear En primer lugar, la posición y esta interfaz va a tener sólo un método para obtener el elemento. Ahora, tenemos que especificar que se trata de un tipo genérico. Entonces cuando decimos d, Ahora, este es un tipo de datos genérico. Y llegamos con esta clase. Ya hemos visto cómo usarlo en, déjame simplemente crear otra clase que es nodo. Entonces vamos a nombrarlo nodo de lista singly enlazado escuchando con S naught. Y como lo hicimos en la posición, que simplemente en D. Y por supuesto vamos a implementar la posición de interfaz. Y, y el método debug get element. Y simplemente, vamos a crear algunos elementos variables fuera. Tenemos el elemento d También tenemos la S nada en sí. A menos que nombre y siguiente. Entonces tenemos a valores privados, variables fuera. Entonces para obtener el elemento, simplemente devolvemos el elemento. Entonces este es nuestro método de elementos de datos. Ahora quizá también queramos devolver el siguiente nodo. Por lo que simplemente decimos público nevado todavía siguiente. Y regresaremos a continuación. Entonces siguiente nodo dos tenemos. Ahora quizá también queramos establecer el siguiente nodo. Por ejemplo, vamos a crear otro método para enviarlo a configurarlo. Tan vacío público, es su nombre y se lo quitará, y tomará un nodo y el pago siguiente. Ahora, estableceremos esto para que sea igual a éste. Entonces lo que hicimos aquí es establecer el siguiente nodo. Tenemos aquí. Se nombra a continuación y ponlo lo lo que tengamos aquí. Entonces esta es la subred. Y si queremos establecer el elemento, tenemos el elemento d simplemente puede crear otro elemento conjunto vacío público. Y en este caso obtenemos un elemento, el elemento y decimos este elemento punto a elemento. Cuando usamos esto, estamos diciendo que necesitamos la variable local d de aquí y configurarla a lo que tengamos, el parámetro aquí. Ahora, vamos a crear nuestra próxima interfaz. Esta interfaz sería, digamos que soy un Teslas. Entonces esta lista S es un poco de interfaz, absolutamente. Y aquí tenemos todos nuestros métodos. Entonces el primer método, y por supuesto es un tipo genérico. El primer método como suele ser del tamaño. Entonces booleano público está vacío. Ahora todavía, también tenemos que contestar. Ahora si vamos a este ejemplo. Entonces esta es nuestra cabeza y este es nuestro dale. Por lo que podríamos querer almacenar un valor en la mano. Entonces vamos a crear un método que almacenaba a la cabeza. Tan vacío público, inserte a la cabeza y lo que sea el animal. También, podríamos querer venderlo a la cola. Entonces contesta. Ahora, ya que es ilimitada, por lo que no tenemos que preocuparnos por la excepción de lista vacía. Cualquier excepción. Esa vez, podríamos querer quitar un elemento usando el remove de Pat. Y en este caso necesitamos lanzar la excepción de lista vacía ya que pueden estar vacías. Y lo mismo ocurrirá si usamos quitado de la cola, arroja una excepción. Por lo que ahora terminamos con nuestra posición de la lista S y continuaremos con esto en el próximo video. 13. Lista única lista única con la parte 2: Entonces ahora que tenemos todos nuestros métodos, vamos a crear una nueva clase y escribirlos. Por lo que esta clase será una clase de lista singulamente vinculada. Y en esta clase vamos a primero que nada, ahondar o implementar la lista S que creamos antes. Pero por supuesto, en primer lugar, podría ser genérico e implementarlo. Podemos tener el 0s y necesitamos heredar los métodos. Ahora tenemos todos los métodos y vamos a trabajar con ellos. Entonces, en primer lugar, tenemos el tamaño. Y antes de eso, vamos a crear algunas variables fuera. El primer variable son los nodos. Como dijimos, tenemos dos nodos, la cabeza, que será el primer elemento o el primer nodo. Entonces este es el nodo principal y la cola está en el último nodo. Entonces tenemos dos nodos como no con E. Y también tenemos señales como de costumbre. Y vamos a crear el StringBuilder para usarlo para el método ToString. Ahora tenemos también la lista constructora República singly-linked. Y aquí, instanciemos la cabeza y la cola para ser iguales a. Por lo que la primera vez que creamos la lista singulamente vinculada, tenemos la cabeza y t igual a ninguno. Y el tamaño será igual a 0. Y crearemos el StringBuilder. Ahora también tenemos aquí. Entonces esto es todo para líquido, el constructor. Empecemos con la ciencia. En primer lugar, para el tamaño, simplemente devolvemos el tamaño. Para el vacío está vacío, simplemente regresamos como de costumbre. Si el tamaño es igual a 0. Ahora pasemos a los otros métodos. Son mucho más complicados y necesitamos trabajarlos lentamente. Por lo que el primer método es insertar a la cabeza. Entonces volvamos al cuadro. Y aquí podemos ver cuatro nodos. Supongamos que necesitamos agregar un nodo aquí. Supongamos que necesitamos agregar una auditoría con un elemento 0. Entonces lo primero que tenemos que hacer es crear el nodo y luego vincularlo a este nodo. Después de eso, necesitamos mover la cabeza ya que tenían estaba aquí. Ahora tenemos que moverlo a aquí. Entonces le daremos la cabeza. El nuevo puesto, que es el nuevo nodo. Entonces volvamos aquí e implementados. Entonces lo primero que tenemos que hacer es crear este nodo. Y llamémoslo sabía como nodo. Será igual a nuevo nodo, este nodo mediante el uso de e. Y el siguiente nodo es, como de costumbre, tenemos esto, esta lista enlazada. Si creamos un nuevo nodo aquí, el siguiente nodo será la cabeza. Ahora, aún lo tenemos y veamos qué es. Entonces sí, necesitamos crear el constructor. Y el nevado nos olvidamos de crear. Entonces volvamos a S nada y creemos nuestro constructor, que es de conocimiento público. Y estoy sirviendo como elemento. Y tomará dos parámetros, a0 y a1. Y elemento será igual a E, max sería igual a. Y ahora podemos volver a nuestra lista singulamente vinculada. Y nosotros, de acuerdo, ahora después de eso, después de crear esto como nodo, necesitamos comprobar si la lista está vacía. La lista está vacía o simplemente podemos decir que F está vacía. Si este es el caso, entonces no tenemos ningún elemento en este nodo. Entonces el primer elemento que vamos a añadir será la cabeza y la cola. Entonces otra vez, di que DE es igual a mu nada. En ambos casos, si está vacío o no, la cabeza será igual a ésta. Por lo que este f solo ejecuta esta línea. Y tenían en ambos casos sería igual a esta nueva asíntota. Después de eso, necesitamos incrementar el tamaño ya que agregamos un nuevo elemento y necesitamos insertarlo en el StringBuilder SPS para que podamos anexar. Pero cuando usamos apéndices, anexamos al final. No obstante, tenemos que agregarla en el primero como primer elemento. Entonces necesitaremos usar inserto, bueno, ¿necesitamos insertarlo en la posición 0? ¿ Y qué necesitamos responder? Tenemos que insertar este nuevo nodo y este nuevo elemento que es E. Y ese es el espacio en blanco aquí. Y hablaremos. Entonces esto es para inserto en la cabeza. Ahora vamos a trabajar con inserto en la cola. Entonces lo primero que necesitamos revisar, insertar una cola es también si está vacía. Ahora vamos a crear el nuevo nodo AST. Como nodo. El nuevo nodo como nodo, el valor de E. Y así el siguiente nodo, como se puede ver en esta imagen, es nulo. Por ejemplo, si desea agregar un elemento aquí, un ODO. Por lo que necesitamos señalar de aquí al nuevo nodo. Y ahora la tabla sería el último nodo. Y este último nodo no señalará nada. No lo será. Entonces volvamos a aquí y trabajemos. Por lo que aquí hemos insertado en el it. En primer lugar, tenemos que comprobar si está vacío. Si está vacío, entonces también es el podría esta nueva nevada. Y en ambos casos, será igual al astronauta. De lo contrario, si no es así, si no está vacío y ya tenemos un elemento. Por lo que este elemento, el último elemento, que aquí es detalle, señalaremos a este nodo. Entonces, ¿cómo lo hacemos? Si no está vacío, entonces cola que sentó siguiente miembro, creamos un método para establecer max y el delta SetText será el nuevo nodo. Ahora, la cola sería este nuevo nodo. Como dijimos. Incrementamos el tamaño y anexamos al final del constructor de cadenas o usando cualquiera de las especificaciones toString LAS, todavía nos hemos quitado del sombrero, quitado de la cola. Y podrías agregar, salir adelante y conseguir cola para echar un vistazo a lo que tenemos en cabeza y cola. Y por supuesto, nuestro último método, ese método toString. Por lo que trabajamos en ellos en el siguiente video. 14. Lista única lista única de la parte 3: Todavía tenemos algunos métodos aquí. Entonces empecemos con el método eliminado de la cabeza. En primer lugar, eliminemos esto. Y lo primero que vamos a hacer es comprobar si la lista está vacía. Entonces si está vacío, entonces necesitamos lanzar la excepción de lista vacía. Escriba la excepción y diga que la lista está vacía. Si este no es el caso, entonces seguiremos sin lanzar esta excepción. Ahora, el elemento que vamos a devolver ese almacenarlo en una variable llamada a regresar. Y es el elemento que está a la cabeza el que obtiene elemento. Entonces ahora tenemos este elemento y lo almacenamos y para regresar. Ahora, si necesitamos comprobar si la cabeza es igual a la cola otra n, En otras palabras, que sólo tenemos un elemento en esta lista, entonces tanto la cabeza como la cola serán iguales a nula en este caso. Entonces f es igual a k, entonces simplemente dirá que AD es igual a, es igual a nueve. Por lo que le trasladamos este elemento. Sólo teníamos un elemento y lo quitamos. Por lo que ahora cabeza y cola serán iguales a nulo. De lo contrario. Si este no es el caso, entonces desde que retiramos de la cabeza, fue quitamos este elemento. Ahora, en lugar de señalar a este elemento, ahora la cabeza será este nodo. Por lo que necesitamos quitar los punteros de la cabeza de aquí a aquí. Entonces para hacer eso, simplemente diremos que la cabeza es igual a encabezar esa siguiente. Siguiente. Entonces esto es todo. Y por supuesto, ya que estamos eliminando un elemento, necesitamos disminuir el tamaño por uno y eliminar de StringBuilder, como el plomo del StringBuilder. Tenemos que empezar con 0 y, y con lo que tengamos aquí. Y este objeto, es volver a la fuerza y la longitud de la misma más un espacio en blanco de pie de cuenta de puntos. Vamos a eliminar y finalmente, volver a regresar. Ahora esto se infiere, quitado de sin cabeza. Continuar con ella se mueve de Taylor. Ahora aquí. Lo mismo. En primer lugar, necesitamos comprobar si está vacío, está vacío, luego lanzamos una excepción diciendo esa lista. Y de lo contrario, continuamos. Tenemos que almacenar el retorno igual a lo que tengamos en detalle desde que quitamos de la cola que obtenemos elemento. Ahora, también necesitamos comprobar si la cabeza es igual a k En otras palabras, es cabeza y colas. El mismo nodo. Por lo que sólo tenemos un elemento. Entonces. Tanto la cabeza como la cola serán iguales a nulo y la lista estará vacía. Entonces si la cabeza es igual a, simplemente decimos que tenía que ser igual para llevar a eso. De lo contrario, solo voy a trabajar con eso ya que nos mudamos a partir de hoy. Entonces volvamos a nuestra imagen aquí. Y veamos, por ejemplo, si queremos eliminar este nodo. Entonces quitamos eso. Ahora, tenemos que decir que la cola es este nodo. Y para ello, recuerden, se trata de una lista singularmente vinculada. No podemos volver de aquí a aquí. Entonces lo que necesitamos hacer es crear un bucle y pasar por todos los nodos hasta llegar a este nodo. Por lo que no queremos al último nodo, necesitamos el que tiene ante sí. Entonces para hacer eso, volvamos a Eclipse e implementemos este código. Entonces, en primer lugar, necesitamos crear un nuevo nodo que no sea la cabeza y la cola. Entonces aquí tenemos la cabeza y aquí tenemos detallado medio para crear un límite atlas. Y pasará por todos los nodos hasta llegar a este nodo. Entonces aquí tenemos un nuevo nodo, D. Nombremos un pueblo en la primera, en la primera posición. Está a la cabeza. Si bien la humedad no es igual a detalle, se ejecutará este código, por lo que será igual a ellos, pero consigue a continuación. Entonces cada vez que comprobamos si la siguiente nota es la cola, si no es la cola, entonces iremos al siguiente nodo. Y llegando a éste. Nosotros, cuando lleguemos a éste, comprobaremos si el siguiente nodo es la cola. Sí, entonces salimos de este while loop. Ahora tenemos nuestra posición, nuestra nueva posición que está aquí, y la humedad está señalando a este nodo. Por lo que simplemente podemos decir que serían iguales al tiempo. Y por supuesto, ya que estamos aquí y ya no queremos a este árabe, simplemente damos este valor, un valor de nulo. Entonces simplemente podemos decir que eso se sentó junto a un valor de nulo. Ya no necesitamos apuntar a ningún nodo después de la cola. Ahora que estamos acabados con este oro, simplemente podemos disminuir el tamaño y barrer, quitar un elemento, y necesitamos eliminarlo desde aquí, desde el StringBuilder. Ahora, veamos cómo podemos eliminar. Por ejemplo, si ahora StringBuilder, tenemos 1234 y tenemos que quitar de la cola. Entonces lo que vamos a hacer es saber cuál es la longitud de esto y menos la longitud del valor final. Por ejemplo, es 12 con el espacio en blanco 34567. Por lo que es siete menos uno, que es seis. Por lo que empezaremos en esta posición y terminaremos la longitud. Entonces, ¿cómo hacemos esto? Simplemente corregimos la longitud de punto sba menos lo que tengamos en este elemento para devolver la cuerda, esa novena minus1. Y terminaremos con SBY, esa longitud. Ahora eliminamos de StringBuilder y simplemente lo devolveremos. Entonces esto es todo para el retirado de Dale. Y vamos a seguir con el otro mensaje. Enviamos, sacamos la cabeza y sacamos la cola. Y por supuesto el último método que es una cadena. Entonces empecemos con el get. Y simplemente forzamos, vamos a lanzar la excepción de lista vacía. Si está vacío. Vamos a lanzar esta excepción. Y esta excepción de que la lista está vacía. Ahora, de lo contrario no es el caso. Entonces simplemente regresamos cabeza que obtenemos elemento. Copiemos este código y creemos get tail. Entonces en lugar de conseguir cabeza o cola y para comprobar si está vacío, lo contrario tenemos una cola que consigue elemento. Ahora, el último método es cadena pública a cadena. Y como usamos el StringBuilder, simplemente podemos regresar, it, devuelve Sb a la fuerza. Entonces estos son nuestros métodos y ahora estamos todos establecidos. Podemos usarlos en una clase de retórica en el siguiente video. 15. Aplicación de la lista única: Ahora que tenemos todos nuestros métodos, sigamos adelante y usarlos en nuestra clase de conductores. Entonces esta es nuestra clase de chófer. Y esta clase, como de costumbre, es el método principal. Vamos a crear la lista de enteros singly enlazada. Y lo mismo solo enlazó lista SLL. Crees que LinkedList. Y en primer lugar, imprimamos el tamaño de la misma. Entonces como tamaño de punto, sigamos adelante y ejecutemos este código. Cuenta de CO2 para suceder. El tamaño es 0. Ahora agreguemos algunos elementos. Entonces dije que inserto en la cabeza uno, SLL, que inserte en para asistir SLL dot insert at tenia tres. Imprimamos aquí la lista de singling. Y ahora vamos a tener 12. Y después de eso insertamos a la cabeza el elemento tres. Entonces esta es la cabeza, así que tenemos 312. Ahora, si insertamos en Tate por ejemplo, insertamos la fecha número uno, y luego imprimimos una vez más. Vamos a conseguir 3121. Ahora, vamos a revisar aquí. Si está vacío, está vacío, y vamos a comprobarlo una vez más. Está vacío. Ejecuta este código, nos hacemos verdaderos al principio y luego después de agregar algunos elementos, nos ponemos falsos. Ahora, todavía tenemos algunos métodos. Por ejemplo, vamos a sacar de la cabeza. Por lo que simplemente podemos guardar ese SLL dot remove de la cabeza. Imprimir SLL. Tenemos aquí. Por lo que este error es una excepción no manejada, necesitamos lanzar esta excepción, conoce Vacío Excepción. Ahora sigamos adelante y ejecutemos este código. Ya no tener tierra. Y obtenemos sentido uno a uno, quitamos este elemento de la cabeza. Hagamos lo mismo a la fecha. Por lo que como LL quitar de la cola e imprimir una última vez. Vamos a conseguir uno a después de quitar el último elemento. Y en todos nuestros ejemplos usamos entero. No obstante, podemos elegir cualquier tipo que desee. Por ejemplo, la cuerda doble, cualquier cosa. Y funcionará de la misma manera. Entonces esto es todo para este video. Nos vemos el siguiente. 16. Stack ack: Ahora, una cosa que podemos hacer esta lista de un solo enlace es crear un paso. Entonces aquí tenemos las clases, esa es una habitación de 100 para esta etiqueta. Entonces vamos a crear nuestra interfaz de pila. Denle su nombre. Y la pila sería genérica. Tipo. Va como de costumbre. El booleano está vacío. Y el empuje. De lo que vamos a empujar el elemento b. B también ese bache. Y por supuesto necesitamos crear la clase de excepción, pero esta etiqueta, así que pila la excepción. Y como de costumbre extender la excepción con el constructor. Pero este mensaje, pero este mensaje y terminamos con esta excepción, lo usaría con Bob y top, así sabe esa excepción. Y aquí también conoce la excepción. Pero la diferencia entre usar listas singly enlazadas y en a es que cuando necesitamos empujar, no tenemos un límite ya que la lista singly enlazada no está limitada. No obstante, cuando usamos array, recuerda que solíamos lanzar aquí también una excepción ya que podríamos estar rebasando el límite del día. Entonces esto es todo para el StatPlus. Ahora sigamos adelante y creemos nuestra pila basada en listas de un solo enlace. Por lo que se trata de una lista singulamente vinculada basada. Y esta lista singularizada que tenemos. Entonces los métodos que creamos en la interfaz. Por lo que simplemente implementaremos la interfaz de pila. Y superior derecha, todos los métodos. Simplemente los sobrescribamos desde E agregando métodos implementados y los métodos. Ahora, lo primero que vamos a hacer es crear la lista singly enlazada fuera antes del constructor, privada lista singly enlazada de D. Ahora vamos a crear un constructor, lista pública singly-linked basada en eso. Y en esto, en este constructor lo hará simplemente. Dar una silla te definió cosa nueva, la lista enlazada. Y por supuesto, aquí tenemos así. Entonces esto es todo y eso es separarlos. Entonces este es nuestro constructor. Ahora pasemos a la ciencia. Mientras se utiliza el tamaño. Simplemente podemos devolver la lista singly enlazada usando está vacía. También podemos utilizar el método IsEmpty disponible y el SLR. Por lo que simplemente devolveremos TODO lo que está vacío. Ahora, lo que estamos haciendo aquí es que hemos creado como lista enlazada. Y lista enlazada. Tenemos todos los métodos. Tenemos insertado cabeza, insertar, quitar, conseguir, y por supuesto tamaño y vacío, lo que podemos usarlos de forma sencilla. Y nuestra pila basada en listas singly-linked, porque el tamaño y es Empty son lo mismo. Ahora cuando vayamos a Bush, voy a seguir adelante. Por lo que utilizamos el empuje desde la cabeza o inserto en la cabeza y la clase singly LinkedList. Entonces para hacer eso, simplemente decimos SLL, pero insertamos en lo que tenemos aquí. Y esto es básicamente ahora. En primer lugar, usemos un bloque try and catch. Por lo tanto, intenta si algo pasó, basta con atraparlo. Y ésta debería ser la lista vacía. Si está vacío. Si la lista está vacía, entonces lo que vamos a hacer es lanzar la nueva excepción que creamos, que es la excepción de pila. Entonces en esto, creamos una nueva excepción diciendo que la pila está vacía. Ahora, esta es la captura. Volvamos a intentar escribir un código aquí. Lo primero que vamos a hacer es crear el objeto. Y también tenemos que quitarnos del sombrero. Entonces en esta pila, como dijimos antes, sumamos la primera y la última salida. Y podemos decir que N es el primero en salir. Por lo que necesitamos seguir adelante. Y ese es el mismo momento si queremos bombear, necesitamos reventar de la cabeza. Por lo que SLL punto, quitar del sombrero. Ahora después de quitar esto, simplemente regresamos. Y terminamos con pub. Vamos sólo a conectar el método que es superior. Entonces como lo hicimos y tratamos de atrapar, atrapar la excepción de lista vacía. Si tenemos una excepción activista, entonces lanzamos una nueva excepción de pila. Y diremos que la pila está vacía. Ahora si este no es el caso, entonces sólo Ser un objeto para devolver y usar el método get de SLL, pero obtener ayuda y devolver este objeto. Entonces esto es todo para el método superior. Y ahora terminamos con todos los métodos por delante y creamos una clase para usarlos. Lo nombraremos pila basada en SLL. Entonces en esta clase, como de costumbre, tenemos nuestro método principal y eso se crea entero oscuro basado en SLL y slim it SLL b igual a nuevo entero de pila. Lo primero que vamos a hacer es crear un empuje, empujar un elemento que es uno, ser el Bush y el gobierno de Bush. Adelante e imprimamos el tamaño, tamaño y este código. A ver qué obtenemos. Entonces nos dieron tres. Ahora nos olvidamos de crear el método toString. Simplemente podemos crearlo después de este método. Y este método será simplemente el SLM. Bien. Ahora volvamos aquí y ejecutemos este código una vez más. Tendremos tres. Ahora si seguimos adelante e imprimimos SLM b obtendrá tres a uno, ya que estamos empujando en la pila. Entonces primero que nada, empujamos uno, luego empujamos dos, Luego empujamos tres. Entonces poniéndolos en D. Ahora si bombeamos de esto, vamos a conseguir SLL B que obtenemos el número tres aquí diciendo que excepción no manejada, necesitamos lanzar esta excepción aquí, lanza la excepción y ejecutar este código obtendrá tres. Ahora si seguimos adelante y lo imprimimos una vez más, llegaremos a uno. Vamos a comprobar si está vacío. Eso está vacío, debería devolver falso ya que tenemos dos elementos. Y por último, usemos el método de las nalgas. Por lo que SLL v punto. Y deberíamos conseguir el número 222 es la primera posición. Entonces esto es todo para la pila basada en listas singly enlazadas. Ahora, implementamos la pila usando tres métodos. El primero es mediante el uso de matriz, y el segundo fue mediante el uso de la pila Java incorporada. Y por último, utilizamos lista singly enlazada para implementar stack. Entonces esto es todo para este video. Nos vemos el siguiente. 17. Lista relacionada doblemente parte 1: Pasemos a la lista doblemente vinculada. Y la lista doblemente enlazada es una estructura de datos enlazada que consiste en un conjunto de chacales de enlace llamados nodos. Cada nodo contiene tres campos para vincular campos al nodo anterior y al siguiente. Y por supuesto, un campo de datos. Entonces, por ejemplo, este nodo contiene un campo de datos para almacenar datos. Y por ejemplo, supongamos que tenemos variable llamada b y dos nodos, dos campos para señalar al nodo anterior y al siguiente nodo. Y por supuesto que tenemos en el primer campo, en el primer nodo, ninguno, y en el último campo, el último nodo y tampoco. Y aquí tenemos la cabeza señalando al primer nodo y el trader señalando al último nodo. Entonces sigamos adelante e implementemos este programa aquí. Entonces vamos a crear un nuevo paquete y nombrarlo doblemente LinkedList. Y en este paquete, empecemos con la creación de nuestra interfaz de posición. Al igual que lo hicimos con una lista singularizada. Contamos con nuestra posición de interfaz. Y en esta posición será genérico, de tipo genérico. Tenemos sólo un método, get element. Entonces esta es nuestra clase de posición. Vamos a crear otra clase. Notaría que la clase se llama D, ya que es una lista doblemente vinculada, el nodo. Y en esta clase, déjame solo, sí, vale, así que aquí vamos a implementar la interfaz de posición. Por lo que simplemente escribiendo implementa posición. Y por supuesto no tienes que anular este método. Obtener elemento. Entonces vamos a crear una variable fuera de este nombre del elemento. Nodos. Necesitamos dos nodos aquí ya que estamos trabajando con anterior y siguiente. Entonces vamos a nombrarlos, denotar lo anterior. Y siguiente. Ahora, en este método, lo que vamos a devolver el elemento, simplemente devolveremos el elemento aquí. En este caso. Ahora, vamos a crear algunos otros métodos. Por ejemplo, necesitamos obtener el nodo anterior. Por lo que será público olvidando y también ser de tipo d nada. Y ese anterior. En este caso, simplemente devuelve el radio, consigue el siguiente. Entonces en este caso, el nodo al siguiente nodo, y simplemente regresamos a continuación. Ahora, podríamos querer configurar el nodo anterior y el siguiente. Entonces vamos a crear un método para configurarlos. Por lo que será de tipo void ya que solo estamos configurando estos nodos. Por lo que establecer anterior. Y tenemos que darle su nombre, su anterior. Y simplemente establecer esta tercera variable local total anterior IE para que sea igual al podómetro para devaluar ingresada por el usuario para el programa. Por lo que será igual a anterior. Y necesitamos crear otro método, métodos, método para establecer a continuación. Como lo hicimos en los dos anteriores, sería este punto siguiente igual a siguiente. Por lo que ahora hemos terminado con el ajuste y conseguir anterior y siguiente. Ahora todavía tenemos sólo un método que es establecer el elemento. Por lo que será un elemento y elemento vacío. Y este elemento igual a elementos. Y ahora terminamos con esta clase. Vamos a seguir adelante y crear alguna clase de excepción. Entonces como de costumbre, en primer lugar, tenemos la excepción de lista vacía. Por lo que yo enumeraría podría estar vacío. Entonces vamos a crear una excepción. Pero esa excepción de lista vacía. Y solo extenderá la excepción con la creación del constructor y el mensaje de excepción de lista y ese mensaje. Entonces esta es la primera excepción. Ahora vamos a crear algunas otras excepciones y hablaremos de ellas más tarde. Por lo que también tenemos excepción de posición inválida. Y será lo mismo. Se extiende la excepción. Y así la última excepción que vamos a crear es la excepción de violación de límites. Por lo que estas excepciones nos facilitarán la detección y pondremos esta estructura de datos de lista doblemente vinculada. Por lo que excepción de violación de límites. Y por supuesto que debería extender la clase de excepción. El constructor. El constructor. Ahora, con hecho con estas clases de excepción. Y podemos seguir adelante y seguir trabajando con nuestra lista doblemente vinculada. Al igual que hicimos con una lista de enlaces individuales, creamos una interfaz para nombrarla lista S. Entonces aquí vamos a crear la lista D ya que es una lista doblemente vinculada. Entonces vamos a crear esta lista D, y luego vamos a anular todos los métodos de esta interfaz a nuestra clase de lista WMA. Entonces lo hacemos en el siguiente video. 18. Lista relacionada doblemente parte 2: Ahora, antes de crear nuestra clase delist, vamos a entender estas excepciones. Entonces, en primer lugar, tenemos la excepción de lista vacía. Y esta clase en esta excepción, ¿quién va a comprobar si la lista está vacía? Por lo que solo lanzaremos esta excepción si la lista podría estar vacía. La otra excepción, la excepción de posición invertida. Entonces, por ejemplo, si el usuario está entrando a un nodo, no está en la lista, entonces vamos a lanzar esta excepción de posición inválida diciendo que el nodo no forma parte de la lista o no lo hicimos e identificamos al nevado. Y por último, la excepción de violación de límites. Entonces al pasar por la lista, por ejemplo, si vamos a usar un siguiente método, vamos a pasar por el nodo y terminamos con el último nodo. Y usamos una vez más, la siguiente. Entonces vamos a lanzar esta excepción de violación de límites, ya que no tenemos ningún nodo después del último. Entonces estas son nuestras tres excepciones, gafas. Y sigamos adelante y creemos la clase denota. Entonces en este caso, este es el Denote, la lista, perdón. Y esta clase será T. Y esto crea un método. En primer lugar, tenemos, como de costumbre, Booleano está vacío, está vacío. Y tenemos el método para obtener el primer elemento, el primer nodo. Por lo que será de tipo denote T y será primero. Por lo que aquí la lista podría estar vacía. Entonces lo que vamos a hacer es lanzar la excepción de lista vacía. Ahora, también podemos crear un método para obtener el último nodo de la lista. Y por supuesto también podría estar vacío. Entonces lanzamos esto hasta la sucesión una vez más. Ahora, déjame ver qué está pasando aquí. El cuerpo método, lo siento, oculto. Necesitamos crear la interfaz e interfaz clase matemática. Y canceló eso. Vamos a crear el método al lado para obtener el siguiente nodo. Entonces aquí tenemos d nada e para conseguir el siguiente. Démosle el nombre siguiente. Y aceptará un denota. Démosle el nombre d. Y después de aceptarlo, aceptando este nodo, aquí tenemos dos temas. En primer lugar, este nodo podría no ser uno de los nodos de la lista. Entonces lo que vamos a tirarlo. La excepción de posición inválida. Dado que esta posición que entramos aquí podría ser inválida en este caso vamos a lanzar esta excepción. Ahora. También podríamos encontrar una excepción de violación de límites, ya que vamos a intentar acceder al siguiente nodo. Supongamos que este nodo es el último, por lo que no podemos acceder al siguiente nodo. Entonces, para arreglar eso, simplemente dibujamos la excepción de violación de límites. Ahora también tenemos el anterior. Entonces tenemos el mismo ADN. El final lanza, excepción de variación inválida y delimitada. Después de eso tenemos dos métodos para quitar y reemplazar. Entonces, antes que nada, vamos a crear el movimiento. Entonces vamos a quitar un elemento. Entonces es div. Vamos a darle un nombre, te has movido, y así lo vamos a quitar del nodo. Nombremos un juicio y lo quitemos. A lo mejor este nodo no es uno de los nodos de la lista. Entonces lo que vamos a lanzar es la excepción de posición inválida. Y vamos a tirar lo mismo si queremos reemplazar, por ejemplo. Nota aquí podría no ser también uno de los nodos de la lista. Entonces vamos a lanzar en posición violeta a continuación. Ahora vamos a insertar. Podemos insertar al principio, insertar al fin, e insertar antes de un nodo, e insertar después. Entonces volvamos a nuestra imagen aquí. Por ejemplo, podemos insertar aquí entre a y b. Así que podemos usar ya sea insertar antes de b o insertar después de a. Y también se puede responder al principio e insertar último. Entonces volvamos atrás y creemos estos métodos. En primer lugar, vamos a crear el nodo e insertar primero. Y vamos a aceptar y elemento d. Entonces lo mismo en clase, inserte la última E, y démosle el nombre E. Entonces tenemos insertar ante un nodo e insertar después de un nodo. Entonces ahora inserta el nodo. Y démosle un nombre, inserte antes. Ahora los vamos a aceptar fuera. Entonces vamos a saber qué nodo insertar antes. Y lo vamos a aceptar aquí. Vamos a nombrar un d y por supuesto, el animal que respecto a insertar. Entonces este es el elemento d. Ahora denotan que se nos da, podría ser y válido. Entonces por supuesto que vas a lanzar la inviolable excepción de posición. Lo mismo con insertar en un nodo específico, inserte después del sname it D, D, E, y E tendrán el lanzamiento de la excepción de posición inválida una vez más. Entonces esto es todo para la clase. Estos todos nuestros métodos por ahora. Y en el siguiente video, los vamos a implementar en la clase de lista doblemente vinculada. 19. Lista relacionada doblemente parte 3: Por lo que tenemos ahora en método en la lista D de la interfaz. Vamos a crear la clase doblemente LinkedList. Por lo tanto doblemente ligada lista. Y en esta clase, vamos a implementar esta interfaz. Y por supuesto vamos a anular todos los métodos para dejarme usar esto y agregar métodos no implementados. Entonces vamos a tener todos los métodos aquí. En primer lugar, vamos a crear nuestras variables construidas y algunas fuera. Entonces como de costumbre, tenemos el tamaño y tenemos dos nodos. Ahora, el D, pongámosles el nombre cabecera y tráiler. Ahora podemos crear nuestro constructor. Y en este constructor va a configurar nuestro encabezado y fracaso y suicidio. Tan tamaño. Después tenemos cabecera y Taylor. Entonces volvamos a esta imagen. Este es nuestro encabezado, y estos son nuestros datos. En primer lugar, no tenemos ningún nodo en esta lista de doble vinculación unirse creando el encabezado y el comerciante, el encabezado debe señalar en el trailer y el sastre debe señalar en el encabezado. Por lo que aquí podemos decir que esta caja señala al sastre y al fracaso, la primera caja debe señalar a la cabeza. Entonces volvamos atrás y veamos cómo podemos implementar esto. En primer lugar, nuestro encabezado será igual al nuevo nodo E, nodo. Nodo E. Y en primer lugar, tenemos, como dijimos, en la clase de posición, déjame ver dónde denotar nuestro. Tenemos elemento anterior y siguiente, pero se olvidó de crear nuestro construido. Entonces eso se crea. Y en este caso, el constructor será de tres parámetros. Se llevará d nodo, nodo D. Vamos a nombrarlo jabonoso anterior y el elemento e. y por último, la d nada, ese es el siguiente nodo. Y por supuesto, pongámoslos aquí. Por lo que el elemento será igual a a, anterior sería igual a b. Y por último, siguiente. Y por supuesto identificó esto. Ahora podemos volver a nuestra nota, y aquí necesitamos crear el siguiente y elemento anterior. Entonces, en primer lugar, ya que no tenemos ningún anterior. A continuación, los ponemos en Null. Y después de eso vamos a crear nuestro tráiler. Ahora, voy a taylor, Como dijimos, debería señalar a la cabecera. Entonces ninguno, ninguno. Y también dijimos que el encabezado también debería señalar a sastre. No obstante, aquí al crear el encabezado, no teníamos ninguna a medida. Entonces en lugar de eso lo vamos a señalar aquí. Encabezado que sentó a continuación. Y vamos a poner al lado el tráiler. Ahora, terminamos con este método y el constructor, quiero decir, y podemos trabajar con nuestro método. Por lo que en primer lugar, tenemos el tamaño simplemente devolverá tamaño. Después tenemos el SMT y como de costumbre determinado tamaño igual a 0. Ahora podemos trabajar con nuestros métodos más complicados. Entonces, en primer lugar, tenemos el primer método y como dijimos, al extraer un nodo, podría enumerar, podría estar vacío. Por lo que para estar en el lado seguro, lanzamos esta excepción de lista vacía. Ahora vamos a crear este método. Entonces aquí tenemos, no queremos extraer el primer denote. Entonces, en primer lugar, vamos a comprobar si está vacío para que la lista esté vacía, entonces vamos a lanzar una nueva excepción vacía. Y en este caso, vamos a decir que la lista está vacía. Ahora bien, este no es el caso. Entonces simplemente regresaremos el primer modo. ¿ Cómo accedemos al nodo disperso? Volvamos a pin. Y podemos ver que siempre que tengamos algunos nodos en la lista, el primero, el encabezado va a señalar en el primer nodo. Y el comerciante que va a señalar en este último nodo. Entonces el eje, el primer nodo, nosotros simplemente, volvamos atrás. Y en Eclipse, simplemente devolvemos lo que tengamos en el encabezado que pone junto al siguiente nodo al encabezado es el primer nodo de la lista. Y lo mismo aquí. En primer lugar, vamos a revisar, así que déjame copiar esto y pegarlo aquí. Si este no es el caso, entonces simplemente regresaremos carcelero que obtenga el nodo anterior. Por lo que después de conseguir el anterior, volvamos a esta imagen y comprobemos. Por lo que aquí tenemos nuestro tráiler. El último nodo de la lista es el nodo anterior a eso más adelante. Entonces lo que sea que esté señalando Taylor es el último nodo de esta lista. Ahora volvamos aquí y trabajaremos con los otros métodos más adelante en los próximos videos. 20. Lista relacionada doblemente parte 4: Pasemos ahora a siguiente, anterior y eliminemos, reemplacemos y demás. Entonces aquí en el siguiente método que podría arrojar una excepción de posición inválida y la excepción de violación de límites. Entonces veamos lo que es una excepción de posición inválida es para nosotros. Entonces, por ejemplo, si el nodo ingresado es ninguno, es evento a no es una posición válida. O, por supuesto, si entramos al encabezado del nodo o tráiler, tampoco hay una posición válida. Y por último, si este nodo está señalando en un nodo siguiente o anterior, como podemos ver aquí, todos los nodos de esta lista deben señalar en el siguiente y en el anterior. Sólo se permite que el encabezado y el tráiler señalen en un solo nodo. Por lo que el encabezado está señalando que el primero y el Taylor en el último. Y aquí no podemos tener ninguno. Y lo mismo aquí. Ahora volvamos aquí. Entonces vamos a crear otro método que nos compruebe las posiciones inválidas con las que podemos trabajar. Por lo que se crea antes de este siguiente método. Eso sería privado ya que lo estamos usando sólo en esta clase. Entonces, llamémoslo vacío privado. Y sólo comprobará la posición y la posición de esta t nada. Y por supuesto debería a través de la excepción de posición inválida. En primer lugar, vamos a comprobar si D no es ninguna. Entonces vamos a lanzar la posición Nueva Invalida. Excepción de posición inválida. Dejar excepción de posición. Y por supuesto, vamos a escribir sanado que nulo no es una posición válida. Y déjame copiar esto y pegar dos veces. Y si D es igual a encabezado, entonces también entraremos en lanzar la excepción de posición inválida, pero diciendo que el encabezado no es una posición válida. Y también el tráiler que va a tirar carcelero no es una posición válida. Entonces lo último que vamos a comprobar es si este nodo D punto siguiente es igual a null. O lo anterior también es igual a nulo, entonces esto no forma parte de la lista. Entonces te vamos a tirar posición inválida. Excepción, decir que el nodo no es parte de un acuerdo es. Ahora terminamos con este método. Podemos usarlo en nuestros métodos aquí. Por lo que en primer lugar, antes de hacer algo, necesitamos revisar la posición. Por lo que llama a este método. Entonces si algo ocurrió como si una excepción de posición inválida de bueno simplemente lo lanzará usando esta posición de cap.. Por lo que va a entrar a revisarlo. Y si no pasa nada, entonces puedes trabajar como de costumbre. Y déjame ver cuál es el problema que debemos regresar. Por supuesto, vamos a devolverlo al final. Entonces, en primer lugar, ya que vamos a conseguir el siguiente nodo, primero, vamos a comprobar si el siguiente es más tarde. Si la puerta de al lado es una cola, entonces podemos conseguir el siguiente nodo. Envía Taylor no forma parte de la lista. Entonces vamos a lanzar la nueva excepción de violación de límites, diciendo que no puede moverse como la última nota. Entonces cuando se cumple esta condición, entonces estamos en el último nodo y no podemos acceder después de eso. Este no es el caso. Entonces simplemente regresamos el siguiente. Ahora, vamos a hacer lo mismo con el get previous. Pero vamos a comprobar si el nodo anterior es el encabezado. Y este caso, no podemos acceder a él ya que no forma parte de la lista. Entonces, en primer lugar, necesitamos revisar la posición. Si todo está bien, entonces podemos continuar. Si anterior es igual a en este caso, la excepción de violación de límite que lo escribimos, una excepción de violación de límite de nueva línea que dice que no puede mover el primer nodo. Y aquí, este no es el caso. Basta con volver los estudios anteriores, los métodos siguientes y anteriores. Sigamos con nuestro método remove. Volvamos atrás. Y supongamos que necesitamos eliminar este nodo. En este caso. En primer lugar, necesitamos cortar estos punteros desde aquí y aquí y crear nuevos punteros. Por lo que a va a apuntar al mar. Y C va a apuntar a. Así que implementemos esto en nuestro código. Para quitar, simplemente creamos. En primer lugar, necesitamos comprobar la posición del nodo. Si todo funciona correctamente, entonces podemos continuar. Por lo que necesitamos regresar. Vamos a crear un retorno de objeto. Y en este caso será el elemento punto-punto. Ahora, antes de establecer estos campos en non, necesitamos establecer estos dos campos en a y C para que apunten el uno al otro. Entonces, ¿cómo accedemos a un? Simplemente podemos escribir ese nodo d dot get previous. Entonces cuando decimos que no se hizo anterior, estamos consiguiendo un y necesitamos establecer un para estar señalando en el mar. Entonces, ¿cómo se hace eso? Simplemente podemos escribir d que se ponga anterior. Ahora, usando get previous, tenemos un. Lo que vamos a hacer es poner este campo para señalar en el mar. Para que eso se sentó a continuación. Nos vamos a poner a continuación. Y cómo accedemos c por a, el dicho de que B, que se ponen a continuación. Entonces qué es, lo que deberíamos escribir aquí es velocidad o DDL GetMax, lo siento. No te pongas a continuación. Entonces déjame repetirlo. En primer lugar, accedimos a un usando DDL get previous después de acceder al anterior. Aquí. Después de decir accidentalmente esta a, simplemente configuramos este campo para que esté señalando en el nodo después de B, y accedemos a eso usando B ya sea conseguir el siguiente. Ahora todavía tenemos que configurar este campo para que esté señalando en a. Entonces, ¿cómo lo hacemos con simplemente acceder al siguiente elemento, al siguiente nodo. Y deberíamos fijar lo anterior a lo anterior. Entonces lo que hicimos aquí es acceder al siguiente elemento, al siguiente nodo. Entonces al usar el punto get next, conseguimos C. Y lo que deberíamos, lo que deberíamos guardarlo aquí en el anterior. Entonces vamos a establecer anterior para estar señalando a una y lo que es un? A es d, D obtendría anterior. Ahora, después de hacer esto, simplemente podemos establecer siguiente de D igual a nulo y el anterior igual a nulo, y simplemente disminuir el tamaño y disuadir el nombre a regresar. Entonces así es como eliminamos el nodo de la lista. Esto un poco complicado a la hora de configurar y llegar hasta aquí. Pero si trabajamos en ello paso a paso, será sencillo. Por lo que seguiremos con el reemplazo en el siguiente video. 21. Lista relacionada doblemente parte 5: Ahora sigamos con el método de reemplazo. En primer lugar, necesitamos comprobar si este nodo es válido. Entonces vamos a usar la posición de chat. El cargo es válido. Entonces puedes continuar. En primer lugar, necesitamos crear un objeto, devolver un elemento para regresar, y devolver lo que tengamos en D. Entonces vamos a establecer el elemento en los dos sea igual a e Y aquí nos falta algo en el reemplazo método. Entonces volvamos a nuestro detesto y arreglémoslo. Cuando necesitamos reemplazar, Necesitamos entrar a un nodo y un elemento. Volvamos aquí y arreglémoslo. Ahora, podemos agregar este elemento aquí y devolver lo que tengamos el objeto a devolver. Ahora, empecemos con el método de inserción. En primer lugar, tenemos el inserto primero. Entonces déjame crear el nodo. Tenemos el elemento aquí en el parámetro. Entonces todo lo que tenemos que hacer es crear ignorado el y vamos a nombrarlo en tu denota. En este caso, el sería igual al ánodo y a la nota. Y tomará tres parámetros. Ahora déjame volver a este cuadro. Supongamos que es necesario crear aquí un nuevo nodo. Este nuevo nodo debe señalar en este nodo a, y a también debe señalar en este nodo que necesito crear. Y por supuesto, cabecera debe señalar en el nodo recién agregado. En lugar de señalar a esto una nada. Entonces déjame volver aquí. En primer lugar, cuando necesitamos crear este nodo, debe señalar en el encabezado. Entonces el elemento e, luego señalar lo que hayamos tenido un get. Siguiente. Después de conseguir este nodo, necesitamos arreglar las flechas. Ahora. Tenemos la flecha señalando de aquí a la cabecera. Entonces déjame arreglar esto simplemente escribiendo head.next. Ahora accedí al primer nodo aquí, que es a Y lo que necesito hacer es establecer anterior para ser igual al nuevo nodo. Entonces simplemente diciendo set anterior. Y en este caso, o eso o simplemente podemos decir que nuevo V nada. Ahora, también tenemos que establecer el encabezado al siguiente. Entonces en lugar de señalar la a, debería señalar en el nuevo nodo. Entonces, ¿cómo fue que se sentó a lado y se sentó al lado del nuevo denotar. Por último, es necesario que se incremente el tamaño. Y por supuesto volver este nuevo denote. Esto es todo para el inserto primero. Sigamos con el inserto último. Una vez que entiendas la idea es la misma para el último, antes y después. Entonces, en primer lugar, necesitamos crear el nodo, el nuevo denotar para ser igual para denotar. Y aquí, cuando queremos responderlo en la última posición, necesitamos configurar nuestro nodo señalando en d de uno esa acción y en el Taylor desde la otra dirección. Por lo que simplemente podemos acceder al nodo simplemente accediendo al punto trailer get elemento anterior es e. Y ahora vamos a modificar las flechas. En primer lugar, el anterior. Entonces en este caso es este nodo D. Y cuando necesitamos, cuando accedemos a él, simplemente podemos establecer el siguiente para que sea igual al nuevo denote. Entonces necesitamos establecer el anterior del Taylor en lugar de ser señalados en d, debe señalar en el nuevo nodo. Por lo que el nuevo anterior denotan. Y por último, el incremento del tamaño determina este nuevo denote. Ahora sigamos con inserto antes. Aquí aceptamos incógnitas. Por lo que debemos revisar la posición de este conocimiento. Y entonces podemos trabajar. Permítanme volver a este ejemplo. Supongamos que tenemos que hacerlo, déjame tomar estos. Y supongamos que necesitamos insertar nodo. Aquí está nuestro nuevo nodo. Y necesitamos configurarlo entre B y C. Así que aquí, C debería señalar en este campo, y por supuesto este campo también debería señalar en el mar. Y lo mismo con B. Así que cuando creamos este nuevo nodo, así que este es el nuevo d nada. Déjame escribirlo aquí. Mu. Y con algunos nuevos denotan y minimizan el frente. Entonces aquí tenemos nuestro nuevo denote, y este nodo es el nodo d Así que aquí estamos obteniendo el nodo D Y necesitamos insertar el nuevo nodo antes de este D. Así que supongamos que este nodo es C0 y necesitamos insertar antes. Entonces, en primer lugar, necesitamos modificar las flechas y crear el nuevo nodo. Entonces déjame hacer click Crear y nuevo denotar D. D, lo siento. Nuevo denote será igual a nuevo V nada. Y en primer lugar, debe señalar en los B y C. Así que desde la primera posición, debe señalar que d dot get previous. Entonces el elemento e, Y entonces debería señalar en D. Ahora, vamos a modificar las flechas aquí. Este nodo debe señalar en este campo. Por lo que para acceder a este nodo, simplemente podemos decir que e dot get previous. Después de obtener el anterior, debemos establecer siguiente y anterior para ser iguales a lo nuevo, denotar. El debería. Deberíamos fijar el anterior de D para que sea igual a nuevo denotar también. Por último, incremente el tamaño y gire este nuevo denote D. Ahora hagamos lo mismo con el inserto después. Entonces aquí, esa posición después de eso crea el nuevo denote, el nuevo nodo igual a denotar. Y volvamos a este ejemplo. Supongamos que necesitamos modificar esta lista agregando un nuevo nodo entre B y C. Pero usamos el inserto después, siento, modificándolo mediante el uso del inserto después de B. Y esto es, lo que debemos hacer, es una vez que configuramos el nuevo denotar, debe señalar en este nodo y luego el siguiente. Por lo que debe señalar que el elemento es e y d, pero consigue el siguiente. Entonces ahora vamos a establecer el siguiente de este nodo, que es en este caso. Y podemos acceder a ella diciendo d dot get next. Ahora, accedimos al segundo nodo y necesitamos establecer para ser iguales a nuevo denote. Entonces el nuevo denotan, incremente el tamaño y devuelva nuevo nodo. Entonces esto es todo para insertar antes e insertar después. Nos vemos en el siguiente video. 22. Lista relacionada doblemente parte 6: Todavía tenemos el método toString, pero será muy complicado ya que tenemos inserto antes e inserto después, Show y necesitamos crear un StringBuilder mid para dar cuenta de la inserción antes de un elemento y después de un animal. Entonces para ser un poco complicado, así que vamos a crear nuestra clase tribal y trabajar en este nombre de clase en la demo DLL. Y él como de costumbre, nuestro principal método. Vamos a crear nuestra lista de doble vinculación, tipo entero, y nombrar listas DLL doblemente enlazadas. Y aquí vamos a sumar algunos valores. Entonces insertemos primero y valoremos uno. Insertar último. Vamos a insertar después del primer nodo. Insertar después de whatnot. Es el primero. Entonces DLL Dios primero. Y necesitamos almacenarlo hacia adelante. Inserción de punto después, antes. Por lo que queremos almacenar antes de la última. Y ahora tenemos algunos errores. A ver. Tenemos excepciones no manejadas para lanzar la clase de excepción. Y ahora imprimamos, por ejemplo, eliminemos un elemento. Entonces para quitarlo, eso es imprimir. Quitamos, eliminamos el elemento, un DLL, el anterior al último elemento. Por lo que el anterior del último elemento. Y en este caso, imprimamos. Nos quitan dos. Ahora, como podemos ver aquí, en primer lugar, entramos uno de los que entramos cinco. Después de la primera posición, después del primer nodo entramos para. Entonces aquí tenemos cuatro y luego tenemos que hacerlo. Entonces cuando tengamos que quitar el elemento antes del último, vamos a quitar éste, y todavía tenemos 145. Entonces vamos a imprimir tamaño DLL, pero tamaño, ahora obtenemos tres. Como se puede ver, tamaño si tres, está vacío, no lo es. Dlls dot está vacío. Te dan pliegues. Ahora bien, si queremos imprimir los elementos de esta lista. Por lo que podemos crear un bucle for comenzando con i igual a 0, igual al tamaño de punto DLL. Pero desde DLL, ese tamaño se puede cambiar mientras se elimina, agregando. Entonces comencemos con una variable exterior escuchando tamaño medio igual al tamaño. Y en este caso, el límite será del tamaño. Ahora vamos a crear un denota afuera. Por lo tanto denotan D igual a a a ser igual a DLL. Pero primero, e imprimimos el elemento. Y antes de eso está en la misma línea. Y luego cada vez que entramos a este bucle, necesitamos modificar el B igual a los dos siguientes, b igual a d, que siguiente. Ahora bien, mientras ejecutaba este código, algo podría suceder. Entonces pongámoslo en un bloque try y catch. Y si es una excepción de cualquier tipo, simplemente tírala de este for loop. Ahora, sigamos adelante y corremos. Este código obtendrá 1425. Por lo tanto, permítanme quitar un elemento aquí. Por ejemplo. Como lo hicimos antes. El LL quitar punto amarillo anterior. Y aún. Entonces sigamos adelante y ejecutemos este código y veamos qué va a pasar con la mudanza a, y terminaremos con esta lista 145. Ahora, también podemos usar este método en la lista doblemente vinculada y crear un método ToString. Pero me pareció más fácil cuando lo usamos en la clase principal ya que estamos creando la lista al mismo tiempo que imprimirla. Entonces esto es todo para la lista doblemente vinculada. Es mucho más complicado que la lista singulamente vinculada, pero es más potente en cuanto a insertar y quitar de cuando queramos. 23. Ordenación de inserción: Considera que tienes una lista de enteros como esta lista. Y quieres que se ordenen de menor a mayor. Oye, puedes usar salazón. Y en realidad hay múltiples algoritmos de clasificación y hablaremos de algunos de ellos. Por lo que dentro por clasificación de inserción. La clasificación de inserción es un simple algoritmo de clasificación que funciona similar a la forma en que viste jugar a las cartas en tus manos. El array se divide virtualmente en una parte ordenada y sin clasificar. Los valores de la parte sin clasificar se recogen y se colocan en la posición actual en la parte ordenada. Y aquí podemos empezar con este ejemplo. Supongamos que tenemos esta lista, y esta lista se dividirá en dos partes, una parte ordenada y no ordenada. Por lo que en primer lugar, nuestra parte ordenada será sólo el primer elemento. Entonces esta es nuestra primera lista, y esta es la segunda parte. Ahora, cuatro ya está ordenado ya que es sólo un elemento, sólo hay un elemento en esta lista. Y no tienes que hacer nada. No hay elemento a la izquierda de que sea mayor que cuatro, entonces necesitamos sumar tres. Entonces tenemos 43. Comparamos tres con cuatro. Por lo que cuatro es mayor que tres. Entonces deberíamos cambiarlos y vamos a conseguir 34. Ahora, la parte ordenada de la lista es 34 y la parte sin clasificar es lo que haya aquí. Y pasaremos al siguiente elemento. Tenemos que comparar dos a 44 es mayor que dos, luego los cambiamos. Y lo mismo que comparamos dos con 33 es mayor que dos también. Así que cambiarlos una vez más, obtendremos 234. Y ahora esta es la parte ordenada y esta es la parte sin clasificar, y así sucesivamente hasta llegar al último elemento de la lista. Y luego terminaremos. Entonces la idea general es comparar cada elemento con todos los elementos a la izquierda. Intercambio. Cada vez que encontramos un elemento a la izquierda mayor que el elemento que estamos utilizando. Entonces sigamos adelante y escribamos el código. Te vas a crear una clase. Y en primer lugar, vamos a crear nuestra matriz de enteros, nuestra lista de enteros. Y por ejemplo, tenemos cinco elementos en esta matriz. Déjame almacenarlos directamente al 5110. Entonces esta es nuestra matriz, y vamos a crear nuestro Método. Pero llamémosle inserción. Y para tomar parámetro una matriz, vamos a nombrarlo en el trabajo aquí. Por lo que en primer lugar, tenemos el bucle for para pasar por todos los elementos de 0 a longitud listada minos1. Ya está ordenado 0, así que no tenemos que empezar con 0. Entonces empezamos con uno. Por lo que nuestro resultado de bucle for con uno y termina una longitud de punto menos uno. Ahora crearemos un entero. Vamos a nombrar clave ID, y será nuestro elemento en esta lista. Entonces estaremos comparando un de i Así que aquí son de tres a 1012 y así sucesivamente. Y lo vendimos y un entero llamado juego. Y tendremos otro entero será j, i menos uno a i menos uno y retrocedemos hasta llegar a 0. Y lo que estamos haciendo aquí es que estamos empezando este número, por ejemplo, que el estado sí caso. La tercera línea, tercera clave en un entero. Y pensamos que este número a un entero llamado clave. Y luego almacenamos la posición que nos estamos recuperando para empezar, que es la posición i menos uno, j i menos uno. Por lo que nos vamos de lado con esta posición y retrocediendo hasta llegar a 0. Por lo que crearemos un bucle while. Si bien j es mayor que 0 y la clave es menor que a de J, necesitamos intercambiar. Entonces a decir aquí es que mientras j es menor, es mayor que 0. Entonces aquí en este caso j es igual a uno. Tan bueno. Y la segunda condición, mientras que clave, que es dos, es menor que a de J, en este caso cuatro. Por lo que necesitamos cambiarlos. Nosotros intercambiamos. Y luego una vez más, comprobamos las condiciones. Tenemos j mayor o igual a 0. En este caso, j es igual a 0. Por lo que esa condición es válida. Y dos en este caso, tenemos aquí dos y aquí cuatro, así 23, entonces tres es mayor que dos. Entonces esto también válido. Tenemos que cambiar una vez más. Y luego terminamos con esto for loop ya que j será mayor que 0. Y en este caso, así que cada vez que ejecutemos este for loop, j será decrementado por uno. Y aquí necesitamos intercambiar esto, crear un entero llamado tamp. Y como de costumbre, que los cambien tomará un de j y almacenamiento aquí, y diez y a de j. A de j más uno en este caso. Y finalmente, tomaremos un j más uno y le daremos el valor de w Así que aquí los cambiamos. Y ahora dijimos, volvamos a imprimir. En primer lugar, imprimamos la matriz tal como está antes de ordenar. Por lo que imprimir en un y algún espacio. Después realiza este método con un a. y luego eso se imprime una vez más. Para que imprimamos la luz del código y el tiempo y vamos a conseguir primero que nada, el sin sal añadido y luego obtenemos el ordenado, ya que utilizamos el método de inserción que creamos aquí. Ahora podemos ver cómo esto cambió cada vez. Así que imprimamos la matriz para crear otro bucle for después de cada cambio en ancho, después de ejecutar el bucle. E imprimir un J2, en este caso, algún espacio. Y luego, y aquí necesitamos imprimir una isla. Antes de ejecutar este bucle y ejecutar el código obtendrá esto. Entonces, en primer lugar, tenemos 32510. Empezamos con yo igual a uno. Por lo tanto, igual a OnReiniciar, t igual a a de i, j es igual a a a de 12, y j es igual a 0 en este caso, que es i minos1 0. Entonces tenemos un bucle while que se ejecutará sólo una vez ya que J es igual a 0 y luego leer recomendado. Por lo que la condición aquí, no será válida para otra ejecución. Por lo que necesitamos cambiarlos ya que se cumplen las dos condiciones. Lo mismo con cinco. Comparamos cinco con ahora. Cinco con 25 es mayor que dos, entonces esta condición no se satisface. No entrará en el bucle for con simplemente aunque e incremente I por uno. Ahora tenemos el número uno. Aquí lo mismo. Compararemos este con cada elemento e intercambiaremos los dos números. Entonces, por ejemplo, 15 los cambiarán. Y luego 13, los intercambiamos una vez más. Y por último, 12 los intercambian. Y por último tendremos 1010 es mayor que todos los demás elementos. Por lo que no entrará al bucle, al bucle while, y terminaremos con los dos bucles, el bucle interno y externo. Y podemos imprimir, imprimir diciéndote mirar hacia fuera la nueva matriz hacia fuera. Entonces esto es todo para la clasificación de inserción. Exploraremos más algoritmos de clasificación en los próximos videos. 24. Ordenación de selección: Pasemos ahora a otro algoritmo de clasificación es la selección. El algoritmo de clasificación de selección ordena una matriz encontrando repetidamente el elemento mínimo de la parte no ordenada y poniéndolo al principio. Ahora estamos considerando orden ascendente. También tenemos el orden descendente en el que podemos encontrar el elemento máximo y almacenarlo al principio. Y como la clasificación de inserción, tenemos dos partes. El que ya estaba ordenado y la parte sin clasificar. Y cada iteración de clasificación de selección, el elemento mínimo de la submatriz sin clasificar se recoge y se mueve a la submatriz ordenada. Entonces usemos un ejemplo. Usaremos la misma lista aquí. Y eliminemos esto. Tenemos este método, eliminar estos. Y vamos a mantener este método funcionando aquí. Pero antes, ejecutemos este código y usemos esta lista. Ahora. Pero lo vamos a hacer en este algoritmo de clasificación es encontrar el mínimo cada vez y almacenarlo en la parte desordenada, la parte ordenada. Por lo que en primer lugar, encontraremos el mínimo y esta lista aquí tenemos uno como mínimo, tomaremos este 11 y lo cambiaremos por este número. Sea cual sea este número, lo cambiaremos por uno. Entonces aquí tenemos uno ahora. Y así déjame escribirlo aquí. Entonces tenemos 1253 y que el siguiente paso es encontrar el mínimo y esta lista. Por lo que el mínimo es cierto y necesitamos almacenarlo en esta posición. Entonces estamos bien ya que el mínimo son dos. Por lo que el siguiente paso sería el mismo que el primero. Sentido, no necesitamos cambiar nada. Ahora, vamos a ver esta lista. Tenemos 5310 y aquí encontramos el mínimo. El mínimo es de tres. Tenemos que almacenarlo en el primer elemento. Por lo que necesitamos cambiar tres con cinco a la siguiente. Es decir, para cambiarlos. Por lo que vamos a obtener 123510 y esquema de vidrio comparó estos dos números como de costumbre, Encuentra el mínimo entre ellos y guárdelo en el primer elemento de esta lista. Y como diez es mayor que cinco, entonces no necesitamos hacer nada. Y esta es nuestra lista final. Entonces ahora sigamos adelante y escribimos como código. Por lo tanto público estático, vacío , selección, parámetro de una matriz, entero. Y en este caso, por ejemplo, en primer lugar, necesitamos almacenar la longitud, la longitud, la longitud para usarlo en el bucle for. Por lo que aquí tenemos la longitud de esta lista. Al lado de nuestro for loop, podemos decir array.length o ambos, lo mismo. Y ahora necesitamos encontrar el elemento mínimo en la parte sin clasificar. Por lo que la parte sin clasificar debería estar empezando por i más uno. Por lo que cada vez que terminemos con compararé y encontraré el mínimo y parte de I más uno a la longitud. Y aquí tenemos n menos uno. Ya que no tenemos que terminar en el último elemento, simplemente podemos agregar y aquí. Y el bucle for interno compararía los dos últimos elementos. Entonces en este caso, vamos a almacenar el mínimo como yo igual a i Y ahora deberíamos encontrar el mínimo y la parte sin clasificar. Por lo que empezamos con i más uno y luego con array, array.length o y la misma simplicidad Maxwell. Y ahora compararemos cada elemento para encontrar el mínimo. Por lo que en primer lugar, consideramos que el mínimo está en el índice i. el índice y un entero llamado mínimo. En primer lugar, soy igual a 0. Por lo que consideramos que el número mínimo en esta lista está en el índice 0 para ir y mirar el índice 00. Entonces encontraremos tres y no es el mínimo. Por lo que necesitamos comparar este número con todos los demás. Y eso es lo que vamos a hacer para comparar una j En este caso, j es la lista de i más uno de aquí hasta el final. Entonces si i de j es menor que array de hombres, entonces necesitamos intercambiar el índice y los hombres, en realidad será el otro anexo. Entonces lo que estamos diciendo aquí es que los hombres serían iguales, y trabajemos con este ejemplo para entenderlo mejor. Entonces, en primer lugar, empezamos con i igual a 0, i igual a 0. Almacenamos en mínimo 0. Ahora estamos mirando este número y j será igual a 0 más uno es uno que se sentó con uno con 1234 y con cuatro. Vamos a comparar array de uno. Si alguno de uno es menor que array de hombres y hombres, recuerda, muchos xn igual a 0 y J, en este caso es igual a uno, irá a comparar T2, que es cualquiera fuera uno con tres, apenas a un mínimo de 0. F dos es menos de tres, entonces mínimo ahora ya no es éste. Ya no está en el índice 0. Está en el índice j, en este caso en el índice uno. Por lo que vamos a dar valor mínimo y nu de uno. Y lo mismo que antes. Ahora, J es igual a dos. Compararía J, I, J y K de dos. Tenemos el I2 aquí, cinco con cualquiera del nuevo mínimo, que es uno. Por lo que debes comparar ahora, es cinco con 25 es mayor que dos, entonces no pasará nada. Entonces vamos a aquí, comparamos array de tres, que es uno con L2. Por lo que uno es menor que T2. Por lo que necesitamos darle al mínimo un nuevo valor, el valor de uno. Y por último, tenemos aquí en qué índice, el valor mínimo ya que después de encontrar el mínimo usando este for loop, necesitamos intercambiar este mínimo con el elemento en la lista ordenada donde debemos resolverlos. Entonces lo que debes hacer es como de costumbre, tomaremos, mínimo, podemos almacenarlo en un entero llamado amortiguado que. Cambiamos lo que sea que haya mínimo con nuestro ojo. Y por último, dar a este i index ID array en el índice i, el valor de la presa. Entonces aquí los cambiamos y volvamos a usar este método aquí. Entonces la selección y las matrices, array. Y lo mismo. Los imprimiremos y conseguiremos 123510. Entonces creo que esa clasificación de selección es más fácil que la inserción. Entonces en términos de comprensión, básicamente es simplemente encontrar el mínimo en el bucle for interno y luego cambiarlo con el primer elemento aquí. Pero aquí. Y esto es para selección, así que te veo en el siguiente video. 25. Ordenación de burbuja: El tercer algoritmo de clasificación del que vamos a hablar es bubblesort. Bubblesort es el algoritmo de clasificación más simple que funciona intercambiando repetidamente los elementos adyacentes si están en aguas subterráneas. Por lo tanto, considere esta lista de cinco elementos. En primer lugar, comparamos los dos primeros elementos y los intercambiamos ya que cinco es mayor que uno. Y luego hacemos lo mismo para el número 235 es mayor que cuatro, entonces deberíamos intercambiar. Entonces este es el nido ahora. Y lo mismo para el número de elemento. 345 es mayor que dos, ella debería intercambiar. Y por último tenemos 58. Y como están en el orden correcto, ocho es mayor que cinco, entonces no intercambiamos. Ahora bien, podemos ver que esta lista aún no está ordenada, ya que tenemos 1424 es mayor que dos. Entonces lo que debes hacer es repetir los mismos pasos y otra vez hasta que lleguemos a la lista ordenada. El peor de los casos, si tenemos el aquí un elemento, por ejemplo, que dicen 0. Por lo que este 0 se debe intercambiar 12345 veces. Tenemos seis elementos en esta lista. Y el peor de los casos es intercambiar este 05 veces. Entonces si tenemos una lista de n elementos, deberíamos intercambiar n menos una vez. Por lo que podemos realizar esta operación n menos una vez, y eventualmente obtendrás esta lista ordenada. Entonces sigamos adelante y escribamos este código para crear otro método. O burbujea con una matriz ID de nombre de parámetro como de costumbre y funcionaría aquí. Entonces, en primer lugar, tenemos un bucle for. Como dijimos, de 0 a n menos uno, podemos decir array.length. Y dentro de este for loop tenemos otro for loop para intercambiar cada dos elementos. Si el código incorrecto para comparamos cada dos elementos adyacentes, a de j es a de j es mayor que a de j más uno. Entonces sólo los intercambiaremos. Vamos a crear un tamp entero. Ahora aquí, primavera de RAM, y lo mismo aquí. Y si consideramos que temp igual a array dot j a j, lo que sea que haya en j más uno. Y luego si j plus1, el valor sal, y este es nuestro método y lo siento, tendremos n menos uno y n menos uno. Usemos esta burbuja y la usemos aquí, e imprimimos la última una vez más. Y vamos a conseguir 325110. Esto es antes de comer y después de salar 123510. Ahora, nuestro código se puede mejorar haciendo una tarea sencilla. Entonces, por ejemplo, aquí, intercambiamos los elementos aquí. Primera vez. Y luego la segunda vez, sólo necesitábamos intercambiar 42. Y esta lista está ordenada ahora. Pero en nuestro ejemplo, estamos obligados a pasar por toda la lista y minús1 veces. Entonces una cosa que podemos mejorar es f. Y llegamos a un punto donde nuestro for loop interno no realizan ninguna tarea, entonces podemos igualar porque no tenemos elementos para intercambiar. Por lo que podemos hacer esta tarea usando un booleano. Entonces, llamémoslo swat. En primer lugar, es, debe ser y no darle el valor aquí le dará el valor dentro de nuestro bucle for externo. Swap dos será primero el igual a false en este caso. Y si, si sólo vomitamos al menos una vez, entonces después de salir de este bucle interno comprobará swap. Si se intercambian igual a falso. Entonces no realizamos ningún intercambio aquí. Por lo que podemos salir del bucle for ya que nuestra lista está ordenada ahora. Para que podamos romper. De lo contrario se mantendrá el intercambio continuo. Y ejecutamos el código, obtenemos el mismo resultado que antes. Pero ahora es mucho más simple y no tomará tanto tiempo como antes. Entonces esto es todo para bubblesort, el algoritmo de clasificación más simple entre todos ellos. Y nos vemos en el siguiente video. 26. Fusión de la composición: Pasando a otro algoritmo de clasificación, fusionar ordenar. Merge sort es un algoritmo divide y conquista. Entonces déjame seguir adelante y crear una nueva clase. Subclase, creado nombre de inserción se fusionó. Y discutirá fusionar sort. En primer lugar, consideremos una pequeña lista de cuatro elementos y luego discutamos una lista más grande. Para, por ejemplo, consideremos una lista con cuatro elementos, 2431. Entonces lo que vamos a hacer es dividir esta lista en dos listas. El primero tendremos 24, contendrá dos elementos, y el segundo tendrá los dos últimos elementos, 31. Entonces ordenaremos cada lista solos. Entonces 24 ya están ordenados, así que no necesitamos hacer nada, solo escribirlos. Y aquí tenemos 31, necesitamos cambiarlos. Entonces esta es nuestra segunda lista ordenada. Y luego después de eso necesitamos fusionarlos. Ya que están ordenados. Por lo que el primer elemento debe ser el más pequeño. Por lo que vamos a comparar el primer elemento en las dos listas. Aquí tenemos 21. Entonces uno es explotado y escribiría uno. Y luego compararemos dos con 32 es menor que dos, y luego tres con cuatro. Lo mismo, orgullo. Y entonces todavía tenemos el último elemento en la primera lista, solo cuatro, y luego terminamos. Ahora, usemos una lista más grande. Tenemos en esta lista siete elementos. Dividimos esta lección a Troilus. Y la primera lista serán cuatro elementos y la segunda tres elementos. Entonces hacemos lo mismo con esta lista dividida en dos listas, dos, y a lo mismo con la otra también. Y todavía tenemos un solo elemento, así que lo dividiremos en uno y haremos lo mismo. Y esta lista, tenemos dos elementos, dividiría en un elemento y cada lista. Y luego tendremos lista 1234567. Cada lista contiene sólo un elemento. Después de eso, necesitamos fusionarlos. Empezamos con los dos elementos aquí. Tenemos veintisiete y treinta y ocho. Veintisiete es menor de lo que escribirías 2738. Lo mismo aquí, 343982. Y después de eso, necesitamos fusionar las dos listas aquí, como hicimos en el ejemplo anterior. Entonces, en primer lugar, tenemos tres, después tenemos veintisiete, treinta y ocho, cuarenta y tres. Aquí lo mismo. Y finalmente tenemos nuestra lista finita final salada. La idea de fusionar ordenar es bastante simple. Se requiere llamar al método sería más de 1s, dos hasta que lleguemos. Lista de un elemento, luego recrear listas ordenadas como se muestra aquí. Adelante y escríbalo ahora. Por lo tanto, para completar el Merge Sort, es necesario escribir dos métodos. podría pensar el primer método, la función principal que ordena la matriz utilizando otro método. Entonces vamos a escribirlo. Vacío público. Vamos a llamarlo público estático, vacío. Y aceptará un entero y sin índice e índice alto. Representan ¿por dónde debemos empezar? Y luego si baja es menor que la dura, entonces podemos continuar. De lo contrario, no necesitamos hacer nada. Significa que lo bajo es mayor o igual a lo alto. En este caso, sólo tenemos un elemento en la lista y no necesitamos citarlo. Entonces estamos trabajando en si lo bajo es menor que lo alto. Entonces lo que debemos hacer aquí es al índice medio igual a bajo dividido por dos. Y entonces lo que haremos es ordenar y dividir la lista en dos listas. Y luego, así la parte izquierda sola y luego así la Derecha pero así puede hacer eso va a entrar nuestro A, tenemos con baja y luego ordenar la derecha pero en un medio más uno. Y después de eso, necesitamos fusionar las mitades ordenadas. Entonces llamaremos a una fusión de límite de método. Y tomará como parámetros izquierda, baja y alta. Y sigamos adelante y creemos nuestro método de fusión. Por lo que tenemos aquí podemos hacerlo privado, privado, estático, vacío, fusionado y como método habitual. Y ahora necesitamos encontrar los tamaños de las dos submatrices y que se fusionen. Por lo que el primer tipo es límite n uno igual a menos uno. Y el segundo es N2 igual a hi menos. Ahora tenemos las dos tallas. Nuevas listas. Por lo que le nombramos lista uno. O podemos emitir izquierda y derecha. Entonces nos queda, el tamaño y la derecha. Este segundo lado. Después de eso, debe copiar los datos de esta matriz original a nuestras dos matrices. Ahora, para hacer eso, simplemente usamos un bucle for con el límite de un1 y copiamos todos los datos de derecha a izquierda. Tan izquierda i igual a i. Y otro for loop para copiar los datos de la parte derecha de la matriz a nuestra lista llamada derecha. En este caso, comenzaremos con una matriz de media más uno y más j Y ahora copiamos los datos aquí. Además, lo siento. Y así es como copiamos nuestros datos. Ahora, necesitamos fusionarlos juntos. Entonces lo que debes hacer es crear un bucle while para copiar todos los datos que almacenamos y copiamos de izquierda y derecha a nuestra actualización original. Entonces como dijimos en este ejemplo, después de ir a esta fase, necesitamos almacenarlos nuevamente en la lista original. Entonces aquí compararemos los dos elementos y luego los iniciaremos y la matriz original y lo mismo aquí. Comparamos estos elementos juntos y obtendremos nuestra lista ordenada. Entonces volvamos a nuestro código y escribamos un bucle while. Y la condición de este while loop que aún tenemos elementos tanto en izquierda como en derecha. Entonces aquí vamos a crear enteros i igual a 0, y lo mismo para J, 0. Y vamos a crear un entero y nombre para nombrarlo, que es igual a o. ahora, mientras que i es menor que n, uno, que es el tamaño de izquierda y J es menor que. Y dos estarán trabajando en este bucle. Ahora primero que nada, compararemos izquierda con derecha de j, de i es menor que j, luego lo almacenamos. Este componente y la lista original. Por lo que a sería igual a izquierda. Y luego incrementamos i Ya que terminamos con esto, por ejemplo, volvamos aquí atrás. Lo que hemos hecho en este caso es que comparamos la izquierda de i aquí, 27 con tres. F, 27 es menor a tres. Deberíamos guardarlo aquí. Ahora, en este caso, 27 es mayor que tres, entonces deberíamos almacenar tres en este caso. Entonces de lo contrario, deberíamos almacenarlo. Y en cualquier k componente derivado e incremento j por uno. Y en ambos casos, deberíamos implementar k Ya que se llenará de cualquier manera. Ahora, después de terminar este bucle while, podríamos tener algunos elementos que quedan en cualquier lista. Por lo que para llenar el original, debemos completar lo que quede en nuestras dos listas. Por lo que creamos un bucle while. Si bien yo es menor que N1. El N1 si i es igual a N1. Y salimos de este while loop por yo igual a uno, entonces este while loop no funcionará ya que sería ya igual línea uno. Entonces si este es el caso, sólo debemos comprar lo que haya en la parte izquierda e incremento, incremento k. Y lo mismo con n2 si j es menor que y hacer exactamente lo mismo, para escribir increment j y k. Entonces ahora terminamos con nuestra función de fusión. Y vamos a seguir adelante y usarla y nuestro método principal. Entonces volvamos atrás. Pero antes revisemos nuestros límites. Aquí tenemos izquierda y derecha y vamos. Aquí. Deberíamos empezar con un nodo. Ya que no estamos sentados con ceros, sentados con cualquiera que sea nuestro índice aquí. Y ahora volvamos atrás y documentemos aquí. Nuestro método principal. Esto crea un retraso igual a, en este caso, cuatro a 718 y utilízalo ahora, usa el tipo con una longitud 0 menos uno. Y luego usa un bucle for para imprimir nuestros elementos. Y discordia 12478. Entonces esto es todo para fusionar. Por lo que nos vemos siguiente video. 27. Orden rápida: Al igual que merge sort, quicksort es un algoritmo divide y conquista. Se necesita un elemento como Pivot y particiona la matriz alrededor del pivote. Hay muchas versiones diferentes de quicksort que gran pivote y diferentes formas. Podemos escoger el pivote como primer elemento. Primer elemento, elemento aleatorio, o el medio. Yo preguntaría explicado qué pivote es en un momento. En primer lugar, vamos a escribir una lista. Entonces considera que tenemos una lista contiene 101819. Y así esta es nuestra lista. Ahora elegimos elemento como pivote. Entonces sigamos adelante y elegimos, por ejemplo, el último elemento y separarlos para entenderlo. Y va a tener que hacer lo mismo aquí. Entonces aquí tenemos esta lista y este es nuestro pivote. Entonces justo aquí abajo. Y aquí tenemos el primer elemento. Ahora necesitamos dos flechas, 2.2 a dos posiciones en esta lista. El primero, comenzamos con el primer elemento de la izquierda y el último elemento antes del pivote. Entonces aquí tenemos nuestra primera, digamos que este es el primer elemento y este es el último. Ahora, lo que va a hacer es comparar el primer elemento si es mayor que el pivote, que necesitamos cambiarlo, necesitamos terminar con una parte que sea menor que el pivote y la otra parte debe ser mayor que el pivote. Entonces para hacer eso, primero, diez es mayor que el pivote. Ahora, entonces se moverá, pasará a 80. Aquí tenemos 80. Entonces ahora estamos en 8050. Por lo que 80 está listo para ser intercambiado. Ahora miraremos a 5050. ¿ Es 50 mayor que el pivote? No, entonces podemos cambiarlo. Por lo que ahora intercambiamos 50 por 80. Aquí tendrá 80, y aquí tenemos 15. Ahora cambiamos las posiciones de estas flechas. Tenemos esta flecha al 42º 30. Ahora, lo mismo hará aquí lo mismo. Tenemos 13, ¿es 30 más bajo que el pivote? Sí. Entonces no necesitamos intercambiar. Se irá a otro ir a 90. Y ahora compararemos 90 con 40. 90 mayor que el pivote? Sí. Entonces necesitamos cambiarlo. ¿ Es 40 menor que el pivote? Sí. Entonces necesitamos intercambiar estos dos elementos, tendrá 90 aquí. Y el, ahora las dos flechas, vamos a nombrarlos para poder ver qué va a pasar. Tenemos bajo y alto. Ahora antes de intercambiar, estas fueron las posiciones y bajo y alto flujo en la posición 0123 y posición alta para. Ahora, después de intercambiar los dos elementos, necesitamos incrementarnos por uno y disminuir alto por uno. Por lo que estaré en posición, en esta posición y baja estará en esta posición. Y siempre que lo bajo sea igual o superior a lo alto, podemos saber que hemos terminado aquí ya que el bajo ha pasado alto. Ahora, lo último que debemos hacer es intercambiar este elemento con el pivote. Por lo que tendrás 17 Y en el pivote 90. Ahora podemos ver que todos los elementos aquí más pequeños que 70, y todos los elementos aquí son grandes y 70. Entonces esta es la idea del QuickSort. Podemos realizar este mismo algoritmo exacto a esta lista. Podemos elegir 40 como el pivote y trabajar en consecuencia. Y lo mismo va aquí. Y dejamos que la recursión haga el trabajo por nosotros. Esta es la idea general y utilizaremos la recursión para poder implementarla más de una vez. Ahora ha surgido. Entonces tenemos dos métodos aquí. El primer método será privado, entero. Vamos a renombrarlo partición. Tomará los parámetros y emitirá y baja. Y este método tomará el último elemento como pivote. El elemento pivotante en su posición correcta en la matriz ordenada. Y casos todos los elementos más pequeños, más pequeños que el pivote a la izquierda y mayores a la derecha. Entonces sigamos adelante y empecemos con este método. En primer lugar, tenemos nuestro pivote se crea. Ahora el vector es igual al último elemento de esta lista. Y tenemos el índice de elemento más pequeño. Se trata de un sname i, que es igual a minús1. Y este caso, comenzamos con nuestro for loop. Empezamos por baja. Todo el camino a. Ahora, necesitamos comprobar si el elemento actual es más pequeño que el pivote. Entonces si j es menor en este caso, y necesitamos incrementar i. uno, swap y array j. Así que vamos a cambiarlo. E igual a editar a. Entonces igual a, perdón, a igual i, igual a j. Y finalmente, de vuelta a G. Así que ahora intercambiamos los dos elementos. Después de terminar con este bucle de palabras, necesitamos intercambiar el pivote con en un i más uno. Entonces en este caso, crear otro momento e intercambiar los dos elementos. Como dijimos. Aquí, tenemos el pivote está en la ubicación a. Y luego dando el bronceado dos. Ahora intercambiamos los dos metadatos por elementos y luego simplemente regresaremos más uno. Entonces este es nuestro método, el método de partición. Este método tomó el último elemento como Pivot, coloca el elemento pivote en su posición correcta en el ordenado en a, y coloca todo más pequeño a la izquierda y mayor a derivado. Ahora, el otro método es la función principal que implementa ese quicksort. Y llamémoslo público estático, vacío. Para que tomara tres parámetros como de costumbre, y bajo y alto. En primer lugar, comprobaremos si el flujo no es mayor que el alto. Podemos trabajar de otra manera no va a funcionar porque no va a tener sentido. Y vamos a tener, vamos a crear un entero, vamos a nombrarlo por, por particionamiento y profundidad. Eso lo hará, donde usaremos este método que creamos aquí. Por lo que pi usaría partición en lo más bajo. Ahora, después de conseguir el índice, pero ahora deberíamos ordenar los dos, abase la parte izquierda, ¿verdad? Pero así usaremos el mismo método una vez más sin otra forma de Pi menos uno. Y lo mismo por más otra forma de escribir. Y luego terminamos con este método. Puedes usarlo. Y nuestro principal método. Entonces creamos una matriz, por ejemplo, vaporizamos, y con algunos valores 426173. Y llamaremos al método de ordenamiento 0. Y en longitud minús1, luego crea un bucle for e imprime los elementos de esta lista. Entonces como de costumbre, con algo de espacio aquí, y sigamos adelante y corremos. El código obtendrá 1234567. Por lo que esta es la matriz se clasifica matriz después de realizar este QuickSort. Entonces esto es todo para Quicksort. Nos vemos en el siguiente video. 28. Búsqueda de salta: Al igual que la búsqueda binaria, saltos Search es un algoritmo de búsqueda para ordenar matrices. La idea básica es comprobar menos elementos que la búsqueda lineal saltando adelante por pestañas fijas o saltando algunos elementos en lugar de buscar todos los elementos de la lista. Entonces por ejemplo, considere que tenemos esta lista. Tenemos 16 elementos aquí. Supongamos que estamos buscando el número 55. Por lo que la búsqueda de salto encontrará el valor de 55 usando algunos pasos. En primer lugar, consideremos que el tamaño de bloque a saltar como para desde 16, raíz cuadrada de 164. Por lo que en primer lugar, saltará del índice 0 al índice cuatro. Por lo que saltará al 01234. Saltar a este elemento en comparación con 5535 sigue siendo mayor que tres. Entonces saltaremos una vez más a cualquiera. Lo mismo aquí, 21 es menos de 55, entonces necesitamos saltar, saltará a 144. Y entonces podemos ver que 144 es mayor que 55. Por lo que volveremos al 21 y realizaremos una búsqueda lineal desde 21244 hasta encontrar nuestro elemento al número 55. Generalmente utilizamos la raíz cuadrada de longitud como el tamaño de bloque a saltar. Porque en el peor de los casos, este es el mejor tamaño de paso a dar. Entonces, empecemos con nuestro código. Saltar. El ij principal de entero y x que vamos a buscar en esta lista. Y aquí, en primer lugar, necesitamos almacenar la longitud del día. Tenemos que elegir nuestra pila. Y como dijimos, tomaremos la raíz cuadrada de n usando la masa. Y esta raíz cuadrada de masa. Por ejemplo, supongamos que tenemos 17 elementos, denle 14 y así como un número. Entonces después de tomar la raíz cuadrada de y formateado usando Math.Floor. Y luego como asignamos un entero para converger a n, y si el elemento existe, entonces necesitamos encontrar el bloque donde está presente el elemento. Entonces volvamos a nuestro ejemplo. Y él 55 está entre 2144. Por lo que necesitamos encontrar estos dos elementos. Y ya tenemos un entero, hemos recreado una otra entidad o vamos a llamarla, por ejemplo, líquido previo a 0. Entonces al principio, el anterior es igual a 0, por lo que está en la posición 0 y el paso está en la posición cuatro. Y si el elemento no se encuentra en este intervalo, entonces deberíamos dar previo el valor de cuatro. Por lo que anterior está ahora en la posición cuatro y necesitamos sumar cuatro al paso. Por lo que paso estaría en la posición ocho y continuar hasta encontrar un elemento de trabajo y esto interpretar y nuestro intervalo. Entonces para hacer eso, necesitamos crear un bucle while y establecer el bucle salvaje como en a es menor que x. ahora, podríamos llegar a un punto donde si seguimos agregando cuatro, el paso, podríamos tener paso mayor que n, entonces no podemos acceder a medio paso. Entonces en lugar de acceder a matriz de paso que dice un radar mínimo entre paso y, y. Por lo que cada vez que ejecutamos este bucle, necesitamos cambiar previo al nuevo valor. Y lo mismo para el paso tres para sumar. Lo que sea que tengamos aquí. Por lo que agregó y luego vamos a obtener anterior es mayor que o igual a. Y entonces estamos terminados. No encontramos al animal que simplemente se volvió minús1. Y él deberíamos cambiar a entero. Ahora. Entonces lo que estamos diciendo aquí en este bucle while, usémoslo en este ejemplo. En primer lugar, tenemos anterior igual a 0 y paso cuatro posición por ahora, pasamos por este bucle while. En primer lugar, comprobaremos array de mínimo entre paso y luego paso es seguramente menor que n. En este caso, paso es igual a cuatro. Entonces matemáticas a un de cuatro, que es tres. En este caso, comprobaremos si tres es menor que x. Sí, entonces seguiremos ejecutando esto mientras bucle cambiará los valores. Ahora, reversa es igual a cuatro y paso es igual a ocho. Y luego comprobaremos si pasamos los límites. Si anterior es mayor que o igual a n, Entonces pasamos los límites y lo hicimos, no encontramos ningún número que coincida con actos. Entonces ahora estamos en la posición cuatro. Y posición ocho. Lo mismo. Comparamos este 21 con 5521 es menor a 55 y necesitamos ejecutar el bucle while una vez más anterior está ahora en la posición ocho. Por lo que esta es posición para, esta es ayuda de posición. Y paso está en la posición 12. En este caso, tenemos 144. Por lo que comparado ciento cuarenta y cuatro, cincuenta y cinco años menos de un 144, entonces saldrá del bucle. Teniendo previo el valor de ocho y paso el valor de 12, entonces tenemos nuestro intervalo y 55 está en este intervalo. Ahora, después de salir del bucle while, necesitamos realizar una búsqueda lineal de x y una y y otro bucle while. Entonces mientras array de resultado con el anterior. Ahora como lo anterior está en la posición ocho y el paso está en la posición ciento cuarenta y cuatro y cincuenta cinco, lo que demostró que receptor está en disenso primer intervalo, entonces comenzaremos con 21 y continuaremos. Tan ancho llevar al anterior es menor que x, entonces incrementaremos en uno. Y si llegamos a un punto donde anterior es igual a cualquiera de los dos pasos, igual a 12 sobre n, Así igual al mínimo entre los dos enteros, cualquiera de los sellos. Y entonces necesitamos romper o devolver minos1 simplemente puede regresar menos uno. En este caso, ya que no encontramos nuestro número. Y luego comprobamos si encontramos el elemento. Entonces si array anterior es igual a x, entonces regresamos esta posición y regresamos menos uno. Si morimos, no lo encontramos. Entonces esta es una t que hemos agregado no puede converger de n booleano, tenemos una falta. Entonces esto es todo, esta es nuestra función. Y sigamos adelante y elijámoslo aquí. Entonces imprimiremos trozo y buscaremos 55. Entonces tomemos esto y los pongamos en nuestro, este es nuestro array y devolverá diez. Por lo que el 55 está en la posición diez. Por lo que estas dos primeras líneas eran de las funciones pasadas ahora esta hora que nuestra posición donde 55 está en esta lista. Entonces esto es todo para saltos. Nos vemos en el siguiente video. 29. Búsqueda de la interpolación: Y otro algoritmo de búsqueda como búsqueda de interpolación. búsqueda de interpolación funciona mejor que la búsqueda binaria. Porque la búsqueda binaria siempre comprueba sobre una base de elemento medio. Pero la búsqueda de interpretación puede ir a diferentes ubicaciones de acuerdo al valor de P a buscar. Entonces por ejemplo, si queremos buscar el número tres y esta lista, si usamos la búsqueda binaria, iremos y comprobaremos en el medio. Entonces o bien 1321034, por lo que este es el medio de la lista. No obstante, si utilizamos la búsqueda de interpolación irá al valor que esté más cerca de nuestro número utilizando una fórmula específica y hablaremos de ello más adelante. Por lo que él tres está más cerca de 0 de lo que está más cerca de 610. Por lo que nuestra fórmula nos llevará a un número entre estos. Entonces la misma idea que la búsqueda binaria, pero en lugar de tener un elemento medio, vamos a tener una posición que va a cambiar de acuerdo a nuestros elementos. Entonces sigamos adelante y creemos nuestro método público. Y llamémosle interpolación. Y como suele tomar una matriz de elementos y el tamaño del elemento, así como el IV o digamos x Ahora, necesitamos establecer nuestro bajo y alto y bajo igual a ser 0 y será y minos1 y loop. Entonces mientras baja es menor o igual a i, lo contrario ya no necesitamos trabajar porque no encontramos nuestro elemento. Entonces es lo mismo que hicimos en la búsqueda binaria. Y tenemos que sumar algunas condiciones. Si bien nuestro elemento x es menor o igual a, nuestro bajo es mayor que o igual, lo siento, y es menor o igual a nuestro elemento. Por lo que mientras se satisfagan estas condiciones, podemos trabajar aquí. Ahora, cada vez que llegamos a un punto donde nuestro bajo es igual a nuestro alto índice, entonces esto significa que lo hemos hecho o bien encontramos el elemento o no. Entonces comprobaremos si sé lo mismo ya que son iguales, es igual a nuestra x. y este es el caso volver bajo, de lo contrario, volver minús1. Y después de revisar esta condición, ahora podemos trabajar, podemos crear nuestra fórmula esa misma posición que saltará. Al igual que hicimos en nuestra búsqueda binaria, creamos una posición llamada elemento metal. Cada vez que vamos al elemento medio ahora, creamos otro entero llamado posición. Y la fórmula es la siguiente. Es así como calculamos la interpolación. Y a de alta menos baja. Entonces lo multiplicamos con yo lo haría x menos a de carga. Y ahora comprobamos si un rayo en esta posición es igual a nuestro elemento, entonces sólo regresamos nuestra posición. De lo contrario, comprobaremos que un en esta posición sea menor que nuestro elemento. Entonces necesitamos cambiar nuestra baja de la posición baja a la alta más una. Lo mismo que hicimos y en búsqueda binaria, pero en lugar de posición y usamos método lo contrario será posición menos uno. Entonces de lo contrario, si el que tenemos en una posición es mayor que x, entonces du sería igual a posición minús1. Y después de terminar esta condición y todo, el bucle while, podemos regresar menos uno si no encontramos el entero. Y ahora volvamos a usarla aquí. Por lo que imprimo la interpolación. Tenemos el a y B y x será el número. Entonces, por ejemplo, supongamos para una búsqueda de b. Y sigamos adelante y ejecutemos nuestro código. Obtendrá para SO tres está en la posición 401234. Cambiemos este número a 89 y obtendremos la posición 11. Por lo que el 89 está en la posición 11. Y lo último que venimos a comprobar si ingresamos un número que no está en esta lección, 900, obtenemos menos uno. Entonces esto es todo para la búsqueda de interpolación. Nos vemos en el siguiente video. 30. Búsqueda exponencial: El último algoritmo de búsqueda del que vamos a hablar es la búsqueda exponencial. La búsqueda exponencial implica dos pasos. En primer lugar, necesitamos encontrar el rango donde está presente el elemento. Y luego haremos búsqueda binaria en lo extraño. Entonces consideremos esta lección. Tenemos 16 elementos y necesitamos encontrar, por ejemplo, 89. Entonces lo que vamos a hacer es, en primer lugar, considerar si nuestro número es igual al primer elemento de esta lista. Si este es el caso, entonces regresamos 0, por lo que está en la posición 0. De lo contrario, comprobamos todos los demás elementos. Empezamos con i igual a uno y con doblete igual a dos, luego yo igual 24816 y así sucesivamente. Y sigamos adelante e implementados para entender mejor esto. Ve aquí y tienes estática pública, y llamémoslo exponencial. Como de costumbre, toma una matriz de enteros y, y, y el valor que vamos a buscar, lo nombraremos x aquí. En primer lugar, como dijimos, necesitamos comprobar si en el índice 0, si el valor está en el índice 0, entonces simplemente devolvemos 0. De lo contrario, necesitamos encontrar el rango para la búsqueda binaria mediante duplicaciones repetidas. Entonces vamos a definir un entero con el valor de uno, y entramos en el bucle. Si bien i es menor que n, la longitud del día. Y a a, a i es menor que nuestro, menor o igual a nuestro número. Este bucle será ejecutado. Por lo que simplemente multiplicaremos i por dos. Por lo que cada vez que entramos a este bucle, multiplicamos i por dos. Entonces veamos aquí en este ejemplo, cuando podemos salir de este bucle. Por ejemplo, si queremos buscar el número 13, primer lugar, comprobamos si 0 es igual a 13. No, no lo es. Entonces definimos i igual a uno y entramos en este bucle. Yo es igual a uno, voy a comprobar. Si bien yo a, a i es menor o igual a x, uno es menor o igual a 13. Sí, entonces multiplicamos i por. Entonces ahora tenemos yo igual a dos, y vamos a ir a nuestro siguiente elemento. Aquí tenemos también uno, es menos de 13 e i es menor que n. Entonces multiplicamos i por 21 tiempo más. Ahora tenemos dos veces 24201234. Ahora estamos aquí. Verificamos el es menor a 13. Por lo que podemos multiplicar una vez más a cuatro veces 28. Entonces ahora somos 5678, estamos en 21. Ahora. Revisaremos 21 es menor a 13. No, no lo es. Entonces. Salimos del bucle con i igual a ocho. Ahora tenemos yo igual a ocho. Y para conseguir nuestro intervalo, tenemos i igual a ocho e i igual a cuatro, que es ocho dividido por dos. Entonces después de encontrar nuestro intervalo aquí, simplemente usamos la búsqueda binaria. Y trabajo en a. Y aquí tenemos yo dividida por dos. Este es nuestro intervalo y mínimo entre i y uno, i y n Ya que podría ser, podría ser que i es mayor que n y no podemos trabajar fuera de nuestros límites. Y aquí tenemos nuestro entero x. Y como necesitamos devolver el tipo, por lo que simplemente giramos la búsqueda binaria. Y luego terminamos. Adelante y usémoslo aquí. Entonces vamos a seguir adelante e imprimir exponencial en array.length y w Vamos a buscar por ejemplo, 13. Y el código conseguirá siete. Por lo que 13 está en la posición siete. Entonces hagámoslo mejor, más bonito. Y exponencial. Guárdalo como exponencial. Y un resultado entero es igual a este exponencial. Si el resultado es mayor a 0, entonces imprimimos el elemento está presente en índice. Y nosotros imprimimos el índice. De lo contrario, imprimimos ese elemento no está presente. Y Ray y agrupar el código obtendrá elemento está presente y el índice siete. Ahora tenemos un atajo en Java que puedes usar. Entonces, en lugar de escribir todos estos, simplemente podemos imprimir una de las dos líneas. Por lo que necesitamos establecer aquí la condición si el resultado es menor a 0, este es el caso. Podemos imprimir. Elemento no está presente. Y la otra afirmación sería elemento está presente, índice. Y nosotros imprimimos el índice. Entonces sigamos adelante y veamos qué habría sido aquí. Vamos a ejecutar el código y obtenemos elemento está presente y el índice siete. Por lo que este atajo, En primer lugar, el método NDA System.out.print. Establecemos la condición tu resultado es menor a 0. Entonces automáticamente este método imprimirá la primera sentencia. De lo contrario, imprimirá lo que haya después de los dos puntos aquí. Por lo que les preguntamos si hay pregunta es menor a 0, sí, imprimir esto. De lo contrario. Imprimir esto. Esto es muy útil si no queremos complicar las cosas y necesitamos una forma de impresión muy sencilla. Entonces esto es para buscar algoritmos. Nos vemos en el siguiente video. 31. Proyecto: Por fin pasemos al proyecto es muy fácil y sencillo uno, y este proyecto tendrá dos pilas y apilar una y empezar a hacerlo. Aquí es necesario empujar algunas fortalezas a estas etiquetas. Entonces por ejemplo, te empujé eres como tenía el bajo para conseguir Hola tenía el, como estás. Ahora lo que hay que hacer es crear este método que se llama merge. Para fusionar la pila uno y comenzar a un nuevo paso y luego almacenarlo en una nueva pila aquí afuera en el método principal. Entonces por supuesto imprimió que usé y pila Java. Pero por supuesto puedes usar la pila que nosotros mismos construimos antes. También puedes usar cualquier tipo de datos aquí en lugar de fuerza. Pero elegí las cosas para sólo ver cómo se vería cuando imprimiera el mensaje o las palabras. Y por supuesto, así es como debería verse tu método. Debería. 32. Recapitulación: Gracias y Felicidades por el discurso de puñetazos. Aquí te presentamos un rápido recapitulación de lo que hemos hecho. En primer lugar, hablamos de pila. Utilizamos matrices y listas singly-linked para implementar estas etiquetas. Después pasamos a las cues y lista individual y doblemente ligada. Y por supuesto, finalmente, hablamos de algoritmos de clasificación y búsqueda. Hemos hecho tantos de ellos, como rápido y bubblesort y búsqueda lineal y binaria. Y aún tenemos la estructura de datos no lineales. Y ojalá los cubramos más adelante en las próximas clases. Entonces gracias por asistir y nos vemos en la siguiente clase.