Apuntes y Código ✍📦

Si te pierdes en algún punto del curso, quieres validar con código de otro estudiante o simplemente necesitas código para insertar datos en alguna estructura pues te dejó la recopilación de mi código por cada estructura. Y al final mi documentación en Notion 🖤

Array

lass MyArray {
    constructor() {
        this.length = 0;
        // contenidothis.data = {};
    }

    // Acceder a un datoget(indice) {
        returnthis.data[indice];
    }

    // Agregar dato al Array
    push(item){
        this.data[this.length] = item;
        this.length++;
        returnthis.data;
    }
    
		// Eliminar el último dato
    pop() {
        deletethis.data[this.length-1];
        returnthis.data;
    }

		// Eliminar dato según su indicedelete(indice) {
        // Desplazar los elementos siguientes al eliminadofor (let i = indice; i < this.length-1; i++) {
            this.data[i] = this.data[i+1]
        }
        
        // Eliminar el espacio que quedó vaciodeletethis.data[this.length-1];
        // Disminuir la longitud del Arraythis.length--;
        returnthis.data;
    }

}


// Instanciaconst miarray = new MyArray();

// Agregar datosconsole.log(miarray.push("Carlos"));
console.log(miarray.push("Santiago"));
console.log(miarray.push("Juan"));
console.log(miarray.push("Jose"));
console.log(miarray.push("Humberto"));
console.log(miarray.push("Diego"));
console.log(miarray.push("David"));

// Eliminar Datosconsole.log(miarray.delete());
console.log(miarray.pop(4));

Strings

const cadena = "Hola";
cadena[0]; // H
cadena[1]; // o
cadena[2]; // l
cadena[3]; // a

Hash Table:

class HashTable {
    constructor(size) {
      this.data = newArray(size);
    }

    // Generar numero random para el hash
    hashMethod(key) {
      let hash = 0;
      for (let i = 0; i < key.length; i++) {
        hash = (hash + key.charCodeAt(i) * i) % this.data.length;
      }
      return hash;
    }

    // Insertar Valorset (key, value) {

        // hashconst address = this.hashMethod(key);

        // Validar si ya hay datos en el hash generadoif (!this.data[address]) {
            
            this.data[address] = [];
        
        }
        this.data[address].push([key, value]);
        returnthis.data;
    }

    // Buscarget (key) {
        const address = this.hashMethod(key)
        const currentBucket = this.data[address];

        if (currentBucket) {
            // Recorrer el Array de Arraysfor (let i = 0; i < currentBucket.length; i++) {
                
                // Pasar por cada Array validando la posición 0 (key)if (currentBucket[i][0] === key) {

                    // Al encontrarlo, retornar la posición 1 (value)return currentBucket[i][1];
                }
            }
        }

        return undefined;
    }

    // Eliminar
    delete (key) {
        const address = this.hashMethod(key)
        const currentBucket = this.data[address];

        // Validar si dicha posición existeif (currentBucket) {
            for (let i = 0; i < currentBucket.length; i++) {

                if (currentBucket[i][0] === key) {
                    
                    // Retornar el valor eliminadoconst item = currentBucket[i]
                    
                    currentBucket.splice(i, 1);

                    return `Item: ${item[0] } : ${item[1]}`

                }
                
            }
        }
        // Undefined en caso de no encontrar la keyqreturn undefined;
    }

    getAll () {
        const AllKeys = [];

        // Recorrer Array Principalfor (let i = 0; i < this.data.length; i++) {
            
            // Validar si en cada posición existe algoif (this.data[i]) {

                const MiniArray = this.data[i];
                
                // Recorrer los Arrays del Arrayfor (let j = 0; j < MiniArray.length; j++) {
                    
                    // Guardar la key
                    AllKeys.push(MiniArray[j][0]);
                }

            }
            
        }

        // Retornar todas las keysreturn AllKeys;
    }
}

// Instanciaconst myHashTable = new HashTable(50);

// Insertar Datos
myHashTable.set("Diego", 1990);
myHashTable.set("Oscar", 2000);
myHashTable.set("Galvis", 2001);
myHashTable.set("Lida", 2020);

// Buscar Value de un key especifico
myHashTable.get("Galvis");

// Mostrar todos los keys existentes
myHashTable.getAll();

// Eliminar por key
myHashTable.delete("Lida")

Listas (Linked List)

// Estructura de un nodo
class Nodo {
    constructor (valor) {
        this.value = valor;
        this.next = null;
    }
}

class SingleList {

    // Para instanciar se debe crear un elemento inicial
    constructor (valor) {
        this.head = {
            value: valor,
            next: null,
        }

        this.tail = this.head;
        this.lenght = 1;
    }

    AddEnd (valor) {
        let currentNode = this.head;while(currentNode.next != null)
        {
            currentNode = currentNode.next;
        }

        currentNode.next = new Nodo(valor);
        this.lenght++;
        this.tail = currentNode.next;return this;
    }
    
    // Agregar al inicio
    AddFirst (valor) {
        const newNode = new Nodo(valor);// Agregar la cabeza anterior al nuevo nodo y convertir el nuevo nodo como nueva cabeza
        newNode.next = this.head;
        this.head = newNode;
        this.lenght++;return this;
    }

    insert (value, index) {
        if (index >= this.lenght) {

            return this.AddEnd(value);            
        
        }

        if (index === 0) {

            return this.AddFirst(value);
        }

        const newNodo = new Nodo(value);
        const FirstPointer = this.getIndex(index-1);
        const NodoAMover = FirstPointer.next;// Anterior -> Nuevo -> Mover
        FirstPointer.next = newNodo;
        newNodo.next = NodoAMover;

        this.lenght++;return this;
    }

    getIndex(indice) {
        let contador = 0;
        let currentNode = this.head;// Recorrer la lista hasta el indice enviadowhile(contador != indice){
            currentNode = currentNode.next;
            contador++;
        }

        return currentNode;
    }

    Eliminar (indice) {

        if (indice === 0) {
            this.head = this.head.next;
            this.lenght--;return this;
        }

        if (indice >= this.lenght) {

            let currentNode = this.head;while(currentNode.next != this.tail)
            {
                currentNode = currentNode.next;
            }

            this.tail = currentNode;
            currentNode.next = null;
            this.lenght--;return this;

        }

        const NodoEliminar = this.getIndex(indice)
        let Prev = this.head;while(Prev.next != NodoEliminar)
        {
            Prev = Prev.next;
        }

        Prev.next = NodoEliminar.next;
        this.lenght--;return this;
    }

}

// Instanciar
let List = new SingleList(1);// Agregar al final
List.AddEnd(2);
List.AddEnd(3);
List.AddEnd(4);
List.AddEnd(5);// Agregar al inicio
List.AddFirst(0);
List.AddEnd(6)

// Eliminar el primero
List.Eliminar(0)
// Eliminar el último
List.Eliminar(7)
// Eliminar intermedio
List.Eliminar(3)

Lista Doble:

classNodo{
    constructor (valor) {
        this.value = valor;
        this.next = null;
        this.prev = null;
    }
}

classListDoble{
    constructor (valor) {
        this.head = {
            value: valor,
            next: null,
            prev: null,
        }

        this.tail = this.head;
        this.lenght = 1;
    }

    append (valor) {
        
        const NuevoNodo = new Nodo(valor); 
        // Siguientethis.tail.next = NuevoNodo;
        // Anterior
        NuevoNodo.prev = this.tail;

        // Nueva cola y aumentar longitudthis.tail = NuevoNodo;
        this.lenght++;

        returnthis;
    }
}

let List = new ListDoble(1);
List.append(2);

Pilas (Stacks) 📚

classNodo{
    constructor(valor) {
        this.value = valor;
        this.next = null;
    }
}

classStack{
    constructor () {
        // Elemento Superiorthis.top = null;
        // Elemento Inferiorthis.bottom = null;

        this.length = 0;
    }

    // Seleccionar el último ingresado
    peek () {
        returnthis.top;
    }

    // Agregar
    push (valor) {
        const NewNodo = new Nodo(valor);

        // Si está vacio, pues agregalo simplementeif (this.length === 0) {
            this.top = NewNodo;
            this.bottom = NewNodo;
            
        } else {
            const Anterior = this.top
            this.top = NewNodo; 
            this.top.next = Anterior;
        }
        
        this.length++;
        returnthis;
    }

    // Mostrar el último elemento
    getBottom () {
        returnthis.bottom;
    }

    // Eliminar el último
    pop () {
        // Validar si hay elementos para borrarif (this.length === 0) {
            return"No hay datos para borrar";
        }

        // Validar si al borrar la Pila quedará vaciaif (this.length === 1) {
            this.top = null;
            this.bottom = null;
            this.length--;
            returnthis;
        }
        
        // Borrarthis.top = this.top.next;
        this.length--;
        returnthis;
    }
}

const Pila = new Stack();
Pila.push(1)
Pila.push(2)
Pila.push(3)
Pila.peek()
Pila.peek()
Pila.peek()
Pila.peek() // Sin datos

Colas (Queues)

classNodo{
    constructor(valor) {
        this.value = valor;
        this.next = null;
    }
}

classCola{
    constructor () {
        // Elemento Superiorthis.top = null;
        // Elemento Inferiorthis.bottom = null;

        this.length = 0;
    }

    // Seleccionar el primer ingresado
    peek () {
        returnthis.bottom;
    }

    // Agregar al final de la cola
    enQueues (valor) {
        const NewNodo = new Nodo(valor);

        if (this.length === 0) {
            this.bottom = NewNodo;
            this.top = NewNodo;
            this.length++;
            returnthis;
        }

        this.top.next = NewNodo;
        this.top = NewNodo;
        this.length++;
        returnthis;
    }

    // Mostrar el último elemento
    getBottom () {
        returnthis.top;
    }

    // Eliminar al primero
    deQueues () {
        // Validar si hay elementos para borrarif (this.length === 0) {
            return"No hay datos para borrar";
        }

        // Validar si al borrar la Pila quedará vaciaif (this.length === 1) {
            this.top = null;
            this.bottom = null;
            this.length--;
            returnthis;
        }
        
        // Borrarthis.bottom = this.bottom.next;
        this.length--;
        returnthis;
    }
}

const Newcola = new Cola();
Newcola.enQueues(1)
Newcola.enQueues(2)
Newcola.enQueues(3)
// Result: 1 (bottom) - 2 - 3 (top) [length=3]

Newcola.deQueues()
// Result: 2 (bottom) - 3 (top) [length=2]

Newcola.deQueues()
// Result: 3 (bottom)(top) [length=1]

Newcola.deQueues()
// Result: "No hay datos para borrar" [length=0]

Árbol Binario de Búsqueda 🌳

classNodo {
    constructor (valor) {
        this.value = valor;
        this.left = null;
        this.right = null;
    }
}

classTreeSearch {
    constructor () {
        // Padrethis.root = null;
    }

    insert (valor) {
        const newNodo = new Nodo(valor);

        // Validar si ya hay algoif (this.root === null) {
            this.root = newNodo;
        
        } else {
            let currentNode = this.root;

            while(true) {
                
                if (valor < currentNode.value) {
                    
                    // Existe algo ahí?if (currentNode.left === null) {
                        
                        currentNode.left = newNodo;
                        returnthis;

                    }

                    // Desplazarse a la izquierda
                    currentNode = currentNode.left;
                
            
                } else {

                    // Existe algo ahí?if (currentNode.right === null) {
                            
                        currentNode.right = newNodo;
                        returnthis;

                    } 

                    // Desplazarse a la izquierda
                    currentNode = currentNode.right;
                
                }  

            }
        }
    }

    search (valor) {
        if (this.root === null) {
            return"No hay datos para poder buscar";
        }

        let currentNode = this.root;

        while (true) {
            
            // Lo encontraste?if (currentNode.value === valor) {
                return currentNode;
            }

            // Es mayor al actual?if (currentNode.value < valor) {
                if (currentNode.right === null) {
                    return"Este dato no existe";
                } else {
                    // Desplazo a la derecha
                    currentNode = currentNode.right;
                }
            } else {
                if (currentNode.left === null) {
                    return"Este dato no existe";
                } else {
                    // Desplazo a la izquierda
                    currentNode = currentNode.left;
                }
            }
        }
    }
}

// Instanciarconst Tree = new TreeSearch();
// Insertar datos
Tree.insert(10)
Tree.insert(4)
Tree.insert(2)
Tree.insert(20)
Tree.insert(15)
Tree.insert(30)

/** RESULTADO:
 *
 *          10
 *      /       \  
 *     4        20
 *   /        /    \
 *  2       15     30
 *
 */// Búsqueda - Funciona
 Tree.search(10)
 Tree.search(4)
 Tree.search(20)
 Tree.search(15)
 // Búsqueda - Error
 Tree.search(33) // Resultado: "Este dato no existe"

Grafos no dirigidos
Representación:

/**
 *  REPRESENTACIÓN DE GRAFOS
 *//** Edge List */
const conex = [
    [0,2],
    [2,3],
    [2,1],
    [1,3]
];

/** List Adyacentes */
            //   0123
const conex2 = [[2], [3,2], [0,1,3], [2,1]]

/** Hash Table */
const conex3 = {
    0: [2],
    1: [3,2],
    2: [0,1,3],
    3: [2,1]
}

/** Matriz Adyacentes (Mejor para: ponderado) */
const conex4 = [
           //0,1,2,3/* 0 */ [0,0,1,0]
    /* 1 */ [0,0,1,1]
    /* 2 */ [1,1,0,1]
    /* 3 */ [0,1,1,0]
]

const conex5 = {
      //0,1,2,30: [0,0,1,0],
    1: [0,0,1,1],
    2: [1,1,0,1],
    3: [0,1,1,0]
}

Código:

classGrafo {
    constructor() {
        this.nodos = 0;
        this.Adylist = {};
    }

    // AddVértice/Nodo
    addVertice(valor){
        this.Adylist[valor] = [];
        this.nodos++;
    }

    // AddConexión/Edge
    addConex(nodo1, nodo2){
        // Conexión entre gragos
        this.Adylist[nodo1].push(nodo2);
        this.Adylist[nodo2].push(nodo1);
    }
}

const Graph = new Grafo();

// Vértices
Graph.addVertice(1);
Graph.addVertice(3);
Graph.addVertice(4);
Graph.addVertice(5);
Graph.addVertice(6);
Graph.addVertice(8);

// ConexionesGraph.addConex(8,4)
Graph.addConex(4,1)
Graph.addConex(1,3)
Graph.addConex(1,6)
Graph.addConex(3,6)
Graph.addConex(3,5)
Graph.addConex(5,4)

/**
    // RESULTADO:
    1: (3) [4, 3, 6]
    3: (3) [1, 6, 5]
    4: (3) [8, 1, 5]
    5: (2) [3, 4]
    6: (2) [1, 3]
    8: [4] 
 
 */

• Repositorio: https://github.com/JuanesGalvis/Estructuras-Datos
• Apuntes: https://www.notion.so/Estructuras-de-Datos-7057cd0c64dd46368b3327ce97ba2ee8