Pregunta clásica de lista vinculada de Niuke: (NC3) el nodo de entrada del anillo en la lista vinculada

Factor de dificultad completo * * * * *, el factor de dificultad de esta pregunta * * *.
Prueba de calor de frecuencia completa * * * * *, este problema de calor * * * * *.

1. Descripción del título

2. Enlace de tema

1. El nodo de entrada del anillo en la lista de enlaces del problema del ganado.

3. Análisis de problemas

1. Primero juzgue si hay un anillo en la lista enlazada, si no, no habrá ningún nodo de entrada, y devolverá directamente nulo. ¿Existe un vínculo?
2. Si hay bucles en la lista vinculada, no se alcanzará nullptr durante el recorrido y se definen un puntero rápido y un puntero lento. 当fast和slow进环以就会围着环同时运动，且fast比slow每次多走一步。直到fast和slow相遇.
3. El punto debe cumplirse dentro del anillo, y luego definir un recuento, en la definición de un nodo RmNodedel siguiente encuentro del nodo del nodo, cuando cada paso cuenta ++, y luego llegar a este nodo count就是这个环里面有多少个结点.
4. Redefinición dos nodos Rnode1, Rnode2 empezar de cero, 让Rnode1先走count步.
5. 再让Rnode1，Rnode2同时走, El punto de encuentro es el nodo de entrada del ring.

3.1 Icono de análisis

3.2 Explicación detallada de los iconos

1. Deje que los punteros rápidos y lentos se encuentren primero en el ring. 图一.
2. A partir del siguiente punto del encuentro, calcula cuántos nodos hay en el anillo. 图二.
3. Defina dos nodos para comenzar desde el principio, deje que un nodo vaya primero el número de nodos en el anillo, y luego los dos anillos irán al mismo tiempo. 图三.

4. Código de resolución de problemas

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
    
    
public:
    ListNode *detectCycle(ListNode *head) {
    
    
        //注释1
        if(head == nullptr || head->next == nullptr)
        {
    
    
            return nullptr;
        }
        //注释2
        ListNode *fast = head;
        ListNode *slow = head;
        ListNode *point = nullptr;
        int count = 1;
        ListNode *RmNode =  nullptr;
        
        while(fast && fast->next)
        {
    
    
            fast = fast -> next -> next;
            slow = slow -> next;
            if(fast == slow)
            {
    
    
                point = fast;
                break;
            }
        }
        //注释3
        if(point == nullptr)
        {
    
    
            return nullptr;
        }
        //注释4
        RmNode = point->next;
        while(RmNode != point)
        {
    
    
            count++;
            RmNode = RmNode -> next;
        }
        //注释5
        ListNode *Rnode1 = head;
        ListNode *Rnode2 = head;
        while(count)
        {
    
    
            Rnode1 = Rnode1 -> next;
            count--;
        }
        //注释6
        while(1)
        {
    
    
            if(Rnode1 == Rnode2)
            {
    
    
                return Rnode2;
            }
            Rnode1 = Rnode1 -> next;
            Rnode2 = Rnode2 -> next;
        }
        
        return nullptr;
    }
};

5. Explicación detallada de los comentarios del código

1. Nota 1: El puntero de la cabeza se anula primero. Para no causar acceso de puntero nulo.
2. Nota 2: Defina punteros rápidos y lentos y déjelos encontrarse en el ring.
3. Nota 3: Si point == nullptr, significa que no hay ningún anillo en la lista vinculada y se devuelve nullptr.
4. Nota 4: Deje que el nodo RmNode comience desde el punto-> siguiente (el siguiente nodo donde se encuentran los punteros rápido y lento) y retroceda, y luego use contar para contar el número de nodos en el anillo.
5. Nota 5: Deje que Rnode1 vuelva a contar los pasos desde el principio.
6. Nota 6: Deje que Rnode1 y Rnode2 retrocedan al mismo tiempo, el punto de encuentro es el nodo de entrada del anillo.

La complejidad del algoritmo para encontrar el nodo de entrada es:

• Complejidad del tiempo: O (n)
• Complejidad espacial: O (1)

1.如有错误或者没能理解的地方，请及时评论或者私信，及时修改更新.
2.会持续更新相关链表高频题目，分类专栏—数据结构.