No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Stacks

16/25
Recursos

Aportes 16

Preguntas 0

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

Un stack basicamente es una pila, es decir, algo que estás apilando, lo primero que entra se queda hasta abajo y lo último que entra se queda hasta arriba, de ahí su nombre LIFO, Las In (El último que entra), First Out (Es el primero que sale).

¿Te suena de algo el logo de stackoverflow? 👀

😄

Las Torres de Hanoi son una forma muy interesante de ver los stacks , el reto consiste en llevar los bloques desde la primera posicion , a la 3 , la regla es no colocar un bloque de mayor longitud encima de uno de menor longitud , claramente podran observar el concepto de pila aplicado de una forma mas dinamica en un juego , la idea es realizar este reto con los menores pasos posibles para cumplirlo.

’

Lo mencionado del V8 es por ejemplo el Call Stack:

Una pila, que valga la redundancia, va apilando al final (Un ejemplo más claro sería una caja con libros apilados, es cerrado por ende no puedes sacar libros de la parte de abajo o intermedia. Lo último que entró es lo primero que sale y así)

🧵 Stacks

<h4>Ideas/conceptos claves</h4>

Una pila (stack en inglés) es una lista ordenada o estructura de datos que permite almacenar y recuperar datos, siendo el modo de acceso a sus elementos de tipo LIFO (del inglés Last In, First Out, «último en entrar, primero en salir»)

<h4>Apuntes</h4>
  • Un stack o pila mayormente tienen una estructura LIFO [Last In, First Out]
  • Los primeros datos en entrar son los primeros en salir
  • Tenemos diferentes métodos para esta estructura de datos
    • Pop ⇒ Remover el último elemento
    • Push ⇒ Agregar un elemento al final
    • Peek ⇒ Tomar el último elemento de la línea

      RESUMEN: Un stack es una pila que los últimos elementos en entrar son los primeros en salir

Otro ejemplo de stack tipo LIFO (Last In First Out)

Las deliciosas tortillas 😍😍❤️

Una observación sobre lo que comenta el profesor:

El método peek te muestra el valor del elemento superior de la pila, pero no lo remueve. “Peek” se traduce como “ojeada”, o sea, sólo “ve” el elemento.

Stack LIFO
Primero en entrar, último en salir.
Push: Adicionar elementos
Pop: Remover elementos

🔆 Un stack permite almacenar y recuperar datos, siendo el modo de acceso a sus elementos: último en entrar, primero en salir.

entonces yo no tengo un stack… tengo un callback hell en mi armario xD

¿Alguien más notó que el muñeco de Diego cambió? Antes era una de color blanco jajaja

Como dato, el método KonMari de Marie Kondo me ayudó a dejar de guardar mis playeras en Stacks y pasar a algo más como una hash table en donde puedo visualizar toda la ropa que tengo y elegir la que yo quiera 😂🤣

aquí un fullstack ha ha ha .-.

class Node {
    constructor(value){
        this.value= value
        this.next = null;
        this.prev = null
    }
}

class MyDoublyLinkedList {
    constructor(value) {
        this.head = {
            value: value,
            next: null,
            prev: null,
        }
        this.tail = this.head
        this.length = 1;
    }

    append(value) {
        const newNode = new Node(value)
        newNode.prev = this.tail
        this.tail.next = newNode
        this.tail = newNode
        this.length++
        return this
    }

    prepend(value){
        const newNode = new Node(value)
        this.head.prev = newNode
        newNode.next = this.head;
        this.head = newNode
        this.length++
        return this;
    }

    insert(value, index){
        if(index >= this.length){
            return this.append(value)
        }
        const newNode = new Node(value)
        let element = this.head
        for (let i = 0; i < index-1; i++) {
            element = element.next
        }
        const tempNode = element.next;
        newNode.prev = element
        element.next = newNode
        newNode.next = tempNode
        this.length++
        return this;
    }
}

let myLinkedList = new MyDoublyLinkedList(1);
myLinkedList.append(3)
myLinkedList.append(4)
myLinkedList.insert(2)
myLinkedList.prepend(0) 

La pila es una estructura de datos lineal en la que la adición o eliminación de elementos sigue un orden particular, es decir, LIFO (último en entrar, primero en salir) Y FILO (primero en entrar, último en salir).

<h4>Staskc</h4>

O pila en español. Piensa en la pila como un conjunto de platos, apilados uno encima de otro, esta estructura de datos tiene un comportamiento tipo LIFO (last in, fisrt out)
.
Es decir lo ultimo que agregamos es lo primero que debe (y puede salir). Continuando con nuestro ejemplo de los platos. Si tenemos 10 platos apilados y queremos el plato numero 4 tenemos que quitar 6 platos primero para poder acceder al plato numero 4.
.
Siempre que agregamos elementos al stack estos se van a la cima de la pila, y asi mismo cuando retiremos elementos siempre sacaremos de esta el elemento en la cima de la pila, es decir, el ultimo elemento que agregamos