Sword se refiere a la serie Offer Sword se refiere a Offer 52: el primer nodo común de dos listas enlazadas

Descripción del Título:

Ingrese dos listas vinculadas y busque su primer nodo común.

Como las siguientes dos listas enlazadas:

La intersección comienza en el nodo c1.

 

Ejemplo 1:

Entrada: intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
Salida: Referencia del nodo con Valor = 8
Explicación de entrada: el valor del nodo de intersección es 8 (tenga en cuenta que si las dos listas se cruzan, no puede ser 0). Contando desde los respectivos encabezados, la lista enlazada A es [4,1,8,4,5] y la lista enlazada B es [5,0,1,8,4,5]. En A, hay 2 nodos antes del nodo de intersección; en B, hay 3 nodos antes del nodo de intersección.
 

Ejemplo 2:

Entrada: intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
Salida: Referencia del nodo con valor = 2
Explicación de entrada: El valor del nodo de intersección es 2 (tenga en cuenta que si las dos listas se cruzan, no puede ser 0). A partir de los encabezados respectivos, la lista enlazada A es [0,9,1,2,4] y la lista enlazada B es [3,2,4]. En A, hay 3 nodos antes del nodo de intersección; en B, hay 1 nodo antes del nodo de intersección.
 

Ejemplo 3:

Entrada: intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
Salida:
explicación de entrada nula : contando desde el encabezado respectivo, la lista enlazada A es [2, 6,4], la lista enlazada B es [1,5]. Dado que estas dos listas enlazadas no se cruzan, intersectVal debe ser 0, y skipA y skipB pueden ser valores arbitrarios.
Explicación: Las dos listas vinculadas no se cruzan, por lo que se devuelve un valor nulo.

responder:

Debido a que las dos son listas vinculadas individualmente, después de que aparece un nodo común, los siguientes valores son todos iguales y hasta el final de las dos listas vinculadas, por lo que lo importante es la lista breve vinculada.

1. Por lo tanto, el primer paso es calcular las longitudes ayb de las dos listas enlazadas, y luego primero mover la lista enlazada larga hacia atrás por ab.
2. Luego mueva las dos listas vinculadas hacia atrás una por una, y luego compárelas, si encuentran lo mismo, salte del ciclo
3. Juzgue arbitrariamente si una lista vinculada está vacía, si está vacía, significa que no hay un nodo que se cruza, y devuelva NULL; de lo contrario, devuelva directamente el nodo

Código:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    int countlen(ListNode *head)
    {
        int a=0;
        auto headx = head;
        while(headx)
        {
            a++;
            headx = headx->next;
        }
        return a;
    }
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
           int lenA = countlen(headA);
           int lenB = countlen(headB);
           if(lenA>lenB)
           {
               for(int i=0;i<lenA-lenB;i++)
               {
                   headA = headA->next;
               }
           }
           else
           {
               for(int i=0;i<lenB-lenA;i++)
               {
                   headB = headB->next;
               }
           }
           while(headA!=headB)
           {
               headA = headA->next;
               headB = headB->next;
           }
           if(headA) return headA;
           else return NULL;
        return 0;
    }
};