Programando Linked List Cycle con Python

Curso de Algoritmos Avanzados: Estructuras de Datos Lineales

Introducción

¿Ya tomaste el Curso Avanzado de Algoritmos: Patrones de Arrays y Strings?

Lista Enlazada

Estructura de datos: Lista Enlazada

Programando listas enlazadas con Java

Cómo Invertir una Lista Enlazada

Odd Even Linked List: análisis del problema

Solución de Odd Even Linked List

Playground: Odd Even Liked List

Programando Odd Even Linked List con C++

Linked List Cycle: análisis del problema

Solución de Linked List Cycle

Playground: Linked List Cycle

Programando Linked List Cycle con Python

Palindrome Linked List: análisis del problema

Solución de Palindrome Linked List

Playground: Palindrome Linked List

Programando Palindrome Linked List con Java

Reorder List: análisis del problema

Solución de Reorder List

Programando Reorder List con JavaScript

Playground: Reorder List Without Repeated Values

Reto: LRU Caché

Ejercicios Prácticos con Listas Enlazadas y Historial de Navegador

Operaciones con Listas Enlazadas: Suma, Intercambio y Navegador

Pilas y colas

Estructura de datos: Pilas y Colas

Paréntesis Válido: análisis del problema

Solución de Paréntesis Válido

Playground: Paréntesis Válido

Programando Paréntesis Válido con C++

Comparación de Cadenas con Backspaces

Colas de prioridad

Estructura de datos: Colas de Prioridad

K Closest Points to Origin: análisis del problema

Solución de K Closest Points to Origin

Playground: K Closest Points to Origin

Programando K Closest Points to Origin con Python

Reorganize String: análisis del problema

Solución de Reorganize String

Playground: Reorganize String

Programando Reorganize String con Python

Colas de Prioridad: Ejercicios Prácticos y Soluciones

Colas de Prioridad y Gestión de Eventos

Próximos pasos

Toma el Curso Avanzado de Algoritmos: Grafos y Árboles

No tienes acceso a esta clase

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

Si ya tienes una cuenta,

Recursos

Aportes 6

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

juanreinaguti

hace 2 años

En el código de la profe solo hay un error en la línea 6 donde se indica el tipo de dato ya que es de tipo "Nodo" debido que la función recibe como parámetro el primer nodo de la lista. Y además como la función está fuera de la clase, no se debe incluir el parámetro "self": ![](https://static.platzi.com/media/user_upload/imagen-17c0485a-5829-4da1-83f1-f64d676c8705.jpg)

John Eduard Meneses González

hace un mes

My Solution!! ![](https://static.platzi.com/media/user_upload/image-88e2264e-1fa2-49ca-9c85-b34b3c9d9671.jpg)

Jose Manuel Florez

hace 9 meses

esta es mi solución en java: ```java public boolean hasCycle (Nodo cabeza){ boolean boolHasCycle = true; //voy a asumir que cada nodo tiene un único valor //entonces al comparar si ya se pasó por ese nodo compararé los valores que tienen dentro if(cabeza == null || cabeza.siguiente == null){ return false; } Nodo apuntadorRapido = cabeza; Nodo apuntadorLento = cabeza; while (boolHasCycle) { if (apuntadorLento.siguiente != null){ apuntadorLento = apuntadorLento.siguiente; } //este lo hago por si algo, pero en mi mente va a llegar siempre el rápido primero a null, en caso de existir un final else { boolHasCycle = false; } if (apuntadorRapido.siguiente != null) { if(apuntadorRapido.siguiente.siguiente != null){ apuntadorRapido = apuntadorRapido.siguiente.siguiente; } else { boolHasCycle = false; } } else { boolHasCycle = false; } if(apuntadorRapido.valor == apuntadorLento.valor){ break; } } return boolHasCycle; } ```

Carlos Castro

hace un año

En TypeScript: ```js /** * Definition for singly-linked list. * class ListNode { * val: number * next: ListNode | null * constructor(val?: number, next?: ListNode | null) { * this.val = (val===undefined ? 0 : val) * this.next = (next===undefined ? null : next) * } * } */ function hasCycle(head: ListNode | null): boolean { if (head == null) { return false } let p1 = head; let p2 = head.next; // Fast pointer while (p1 != p2) { if (!p2 || !p2.next) { return false; } p1 = p1.next; p2 = p2.next.next; } return true; }; ```/\*\* \* Definition for singly-linked list. \* class ListNode { \* val: number \* next: ListNode | null \* constructor(val?: number, next?: ListNode | null) { \* this.val = (val===undefined ? 0 : val) \* this.next = (next===undefined ? null : next) \* } \* } \*/ function hasCycle(head: ListNode | null): boolean { if (head == null) { return false } let p1 = head; let p2 = head.next; // Fast pointer while (p1 != p2) { if (!p2 || !p2.next) { return false; } p1 = p1.next; p2 = p2.next.next; } return true; };

Francisco Roberto Gomez

hace 2 años

Lo había pensado como en la segundo versión de la profe pero agregue en el if que si lento estaba después de rápido arrojara true. Dejo mi ejecución en c++

template<class T> bool Lista<T>::hasCycle(){
    Nodo<T> *rapido=inicio;
    Nodo<T> *lento=inicio;

    if (inicio== nullptr){
        throw 404;
    }

    if (inicio->getSiguiente()== nullptr){
        return false;
    }

    while (rapido->getSiguiente()!= nullptr || rapido== nullptr){

        if (rapido->getSiguiente()==lento || rapido==lento){
            //hay algun ciclo
            return true;
        }

        lento=lento->getSiguiente();
        rapido=rapido->getSiguiente()->getSiguiente();
    }

    return false;
}

Nicolas Alpargatero

hace 2 años

Me da curiosidad que dijo que lento y rápido iniciaban en el mismo, pero en la implementación no, aun así, ayudo bastante afianzar Linked List.