Conclusiones

Si alguien quiere ejercicios para entrenar las estructuras de datos aquí hay de sobra 😃
https://leetcode.com/explore/learn/

Estuvo genial el curso, me sirvió para refrescar, como dije, este curso lo tenía en la mira desde que lo vi en la ruta de aprendizaje y preparé algunos gifs para poder explicar mejor estos conceptos.
.
Solo me hizo falta el gif de los grafos, pero bueno, se entendió jaja, yo amo las estructuras de datos, estaría genial verlas pero ahora orientada a un lenguaje como C++.
.
Yo aprendí con C++ y este lenguaje ya incluye librerías que tienen sus propias estructuras de datos ya predefinidas, dato curioso, en C++ un array dinámico se llama “vector” ^^

Les comparto mis apuntes del curso 😉

Contienen:

• Mi repositorio del curso
• las Diapositivas del curso
• Mis apuntes
• apuntes hechos con 💚

Todos los cursos de Diego De Granda me han parecido brutales!!

Cuando empecé pensaba que sería un curso complejo (Dado que ya había visto estructura de datos con Java en la universidad) y más cuando pasamos de cosas simples como el Array, Strings o Hash Table a cosas más difíciles como listas, pilas, colas, árboles y grafos. Y al finalizar sentí que aprendí demasiado y nada de lo que vimos fue complicado.

Había quedado con las ganas de verlo aplicado, por ejemplo si tengo una BDD en mongo y CRUD como podría aplicar un grafo? O cuándo usar un árbol? Pero con lo dicho de un próximo curso de eso, ufffff me dejo emocionado jajaja gran curso!

Un curso muy esperado y necesario que complemetna bastante bien los cursos de algoritmos.
.
Me gustaria que actualizaran los de algoritmos y los implementaramos en js.
.
Cuando me fui interesando por el tema de los algoritmos tuve que investigar por mi cuenta muchas estructuras de tos, sus metodos y sus comportamientos, con este curso entendi un poco mas, reforce conocimientos que ya tenia, y sobre todo practique con los retos de las clases 😃✌🚀

Me gusto mucho el curso, degranda haz un remake del curso profesional de Js pls

Excelente curso te aclara muchas cosas del lenguaje Javascript y lo mejor es que con los retos adquieres conocimiento para desarrollar mas fácil.

Ya quiero ver ese curso de algoritmos de la vida real con estructuras de datos, De Granda es un gran maestro, lo admiro y si que se aprende mucho.
Nunca pares de aprender :gree

Muy buen curso, siempre le había tenido miedo a las estructuras de datos y en este curso supere esta fobia. Ahora a practicar en mi empresa. Gracias Diego.

Aquí pueden encontrar los costos computacionales de las estructuras de datos que estuvimos viendo: Big O CheatSheet

Otro increíble curso de Diego de Granda, me llevo de tu curso bastante conocimiento, motivación, practica y ganas de aplicarlo en proyectos.

Sigue haciendo mas cursos De Granda, ayudas a esta gran comunidad de Platzi 💚 a seguir creciendo.

Que bueno, me encantó este curso, excelente profe, me emociona lo que menciona del curso de algoritmos, buenísimo.

Que belleza de curso, me encantó, muchas gracias

Muy contento de tener acceso a este curso para aprender y/o reforzar estos conceptos que nos ayudan a encarar problemas más complejos , llevándonos más lejos en nuestra carrera como desarrolladores. Excelente curso!

Un gran curso, ayuda a mejorar la habilidad lógica y tambíen a introducirse en el mundo del manejo de la información lo cual es vital en Backend en mi caso, mi futuro cercano. Volveré por más cursos de Diego de Granda, Gran profesor!.

necesitamos mas cursos asi!!!

Les comparto el método de borrar un nodo, por si a alguien le interesa.

Excelente curso, es la primera vez que comprendo grafos y que puedo implementarlo, aunque sea de manera sencilla.

Un muy buen profesor y espero tener más curso de él.

Entiende(de verdad) como funciona una singly linked list y todas las demás estructuras será mas fáciles de entender.

Me encantó el curso!, nunca había escuchado sobre las estructuras de datos. Pero sin duda, cuando se me presente algo con estructuras de datos, ya sabré de lo que me hablan jaja

Buen día, aquí te comparto mis notas sobre el curso, espero te sea de utilidad:

• Notas del curso
• Para activar el modo oscuro presiona CTRL + SHIFT + L.

No estuvo tan dificil, ahora si a implementarlo en algo con node 😃

Esto es mucho mas facil de lo que pense jajaj gracias por darme esta sensacion maestro XD

codigo del curso y algunos complementos
https://github.com/ricardo1470/Data-Structures

Qué buen curso, bastante completo, sinceramente

que curso mas complicado mas cuando uno no ah ejercido completamente!!! pero interesante!!!

No se donde reportar esto, pero una de las respuestas del examen esta errada.
Los nodos en el siguiente nivel no se llaman de ninguna de las formas que presentan las opciones.

Después de mucho ensayo y error creo que finalmente lo conseguí.
Comparto el código de como hice la representación en las 3 formas que vimos (edge list, adj list y adj matrix):

class Graph{
  constructor(){
    this.nodes = 0;
    this.edgeList = [];
    this.adjList = {};
    this.adjMatrix = {};
  }
  addVertex(node) {
    this.adjList[node] = [];
    this.adjMatrix[node] = [];
    this.updateAM(node);
    this.nodes++;
  }
  updateAM(node) {
    for (let i = 0; i < this.nodes; i++) {
      this.adjMatrix[node].push(0);
    }
    for (let key in this.adjMatrix) {
      this.adjMatrix[key].push(0);
    }
  }
  addConex(node1, node2){
    if (!this.adjList[node1]) this.addVertex(node1);
    if (!this.adjList[node2]) this.addVertex(node2);
    if (this.adjList[node1].includes(node2)) 
      return console.error(`${node1} y ${node2} ya están conectados`);
    this.addEL(node1, node2);
    this.addAL(node1, node2);
    this.addAM(node1, node2);
    return this;
  }
  addEL(node1, node2){
    const pair1 = [node1, node2];
    const pair2 = [node2, node1];
    this.edgeList.push(pair1,pair2);
  }
  addAL(node1, node2){
    this.adjList[node1].push(node2);
    this.adjList[node2].push(node1);
  }
  addAM(node1, node2){
    let pos1=0, pos2=0;
    for (let key in this.adjMatrix) {
      if (key == node1) break;
      pos1++;
    }
    for (let key in this.adjMatrix) {
      if (key == node2) break;
      pos2++;
    }
    this.adjMatrix[node1][pos2] = 1;
    this.adjMatrix[node2][pos1] = 1;
  }
}

Hacer la matriz de adyacencia fue lo más complicado, pero creo que con este resultado siento que he reforzado mis conocimientos.

Excelente curso. Repasé todas las estructuras y aprendí cómo implementar grafos en código.

Muy bueno el curso. Honestamente me costó trabajo ( me falta desarrollar más la parte de algoritmos). Tomaré los cursos de algoritmo. Recomiendo dos cursos (complemento básico). El de lógica, y bases de datos (introducción). Gracias Profesor Degranda. Gracias Platzi. Para ser honesto, lo volveré a tomar dentro de una semana (reforzar).

Agrego mi repositorio donde está mi implementación de las estructuras de datos vistas en este curso.
https://github.com/joseoliva762/JavascriptDataStructure.git