Controlla se due elenchi collegati si uniscono. In caso affermativo, dove?

Questa domanda potrebbe essere vecchia, ma non riuscivo a trovare una risposta.

Diciamo, ci sono due elenchi di lunghezze diverse, che si fondono in un punto ; come sappiamo dov'è il punto di fusione?

Condizioni:

1. Non sappiamo la lunghezza
2. Dovremmo analizzare ogni elenco solo una volta.

Se

• con "la modifica non è consentita" si intendeva "puoi cambiare ma alla fine dovrebbero essere ripristinati", e
• potremmo iterare gli elenchi esattamente due volte

il seguente algoritmo sarebbe la soluzione.

Primo, i numeri. Supponiamo che la prima lista sia di lunghezza a+ce la seconda sia di lunghezza b+c, dove cè la lunghezza della loro "coda" comune (dopo il punto di unione). Indichiamoli come segue:

x = a+c
y = b+c

Poiché non conosciamo la lunghezza, la calcoleremo xe ysenza iterazioni aggiuntive; vedrai come.

Quindi, iteriamo ogni elenco e li invertiamo durante l'iterazione! Se entrambi gli iteratori raggiungono il punto di fusione contemporaneamente, lo scopriamo semplicemente confrontando. Altrimenti, un puntatore raggiungerà il punto di unione prima dell'altro.

Dopodiché, quando l'altro iteratore raggiunge il punto di unione, non procederà alla coda comune. Invece tornerà al precedente inizio della lista che aveva raggiunto il punto di unione prima! Quindi, prima che raggiunga la fine della lista modificata (cioè l'inizio precedente dell'altra lista), farà il a+b+1totale delle iterazioni. Chiamiamolo z+1.

Il puntatore che ha raggiunto per primo il punto di unione, continuerà a scorrere fino a raggiungere la fine dell'elenco. Il numero di iterazioni che ha fatto dovrebbe essere calcolato ed è uguale a x.

Quindi, questo puntatore torna indietro e inverte nuovamente gli elenchi. Ma ora non tornerà all'inizio dell'elenco da cui originariamente era partito! Invece, andrà all'inizio dell'altro elenco! Il numero di iterazioni che ha fatto dovrebbe essere calcolato e uguale a y.

Quindi conosciamo i seguenti numeri:

x = a+c
y = b+c
z = a+b

Da cui lo determiniamo

a = (+x-y+z)/2
b = (-x+y+z)/2
c = (+x+y-z)/2

Che risolve il problema.

Quello che segue è di gran lunga il più grande di tutto quello che ho visto - O (N), nessun contatore. L'ho ricevuto durante un'intervista a un candidato SN a VisionMap .

Crea un puntatore interattivo come questo: va avanti ogni volta fino alla fine, quindi salta all'inizio dell'elenco opposto e così via. Crea due di questi, indicando due teste. Avanza ogni volta di 1 ogni indicatore finché non si incontrano. Questo accadrà dopo uno o due passaggi.

Uso ancora questa domanda nelle interviste, ma per vedere quanto tempo impiega qualcuno a capire perché questa soluzione funziona.

La risposta di Pavel richiede la modifica delle liste e l' iterazione di ciascuna lista due volte.

Ecco una soluzione che richiede solo di iterare ogni elenco due volte (la prima volta per calcolare la loro lunghezza; se la lunghezza è data, devi solo iterare una volta).

L'idea è di ignorare le voci iniziali dell'elenco più lungo (il punto di unione non può essere lì), in modo che i due puntatori siano alla stessa distanza dalla fine dell'elenco. Quindi spostali in avanti finché non si uniscono.

lenA = count(listA) //iterates list A
lenB = count(listB) //iterates list B

ptrA = listA
ptrB = listB

//now we adjust either ptrA or ptrB so that they are equally far from the end
while(lenA > lenB):
    ptrA = ptrA->next
    lenA--
while(lenB > lenA):
    prtB = ptrB->next
    lenB--

while(ptrA != NULL):
    if (ptrA == ptrB):
        return ptrA //found merge point
    ptrA = ptrA->next
    ptrB = ptrB->next

Questo è asintoticamente lo stesso (tempo lineare) della mia altra risposta ma probabilmente ha costanti più piccole, quindi è probabilmente più veloce. Ma penso che la mia altra risposta sia più interessante.

Bene, se sai che si uniranno:

Supponi di iniziare con:

A-->B-->C
        |
        V
1-->2-->3-->4-->5

1) Scorri il primo elenco impostando ogni puntatore successivo su NULL.

Adesso hai:

A   B   C

1-->2-->3   4   5

2) Ora scorri il secondo elenco e attendi fino a quando non vedi un NULL, che è il tuo punto di unione.

Se non puoi essere sicuro che si uniscano, puoi usare un valore sentinella per il valore del puntatore, ma non è così elegante.

Se potessimo iterare gli elenchi esattamente due volte, posso fornire un metodo per determinare il punto di unione:

• itera entrambe le liste e calcola le lunghezze A e B
• calcolare la differenza di lunghezze C = | AB |;
• inizia a iterare entrambe le liste contemporaneamente, ma esegui ulteriori passaggi C sulla lista che era maggiore
• questi due puntatori si incontreranno nel punto di fusione

Ecco una soluzione, computazionalmente veloce (itera ogni elenco una volta) ma utilizza molta memoria:

for each item in list a
  push pointer to item onto stack_a

for each item in list b
  push pointer to item onto stack_b

while (stack_a top == stack_b top) // where top is the item to be popped next
  pop stack_a
  pop stack_b

// values at the top of each stack are the items prior to the merged item

Puoi usare un insieme di nodi. Scorri un elenco e aggiungi ogni nodo al set. Quindi itera attraverso il secondo elenco e per ogni iterazione, controlla se il nodo esiste nell'insieme. Se è così, hai trovato il tuo punto di unione :)

Ciò probabilmente viola la condizione "analizza ogni elenco solo una volta", ma implementa l' algoritmo tartaruga e lepre (usato per trovare il punto di unione e la lunghezza del ciclo di un elenco ciclico) in modo da iniziare dall'elenco A e quando si raggiunge il NULL al alla fine fingi che sia un puntatore all'inizio dell'elenco B, creando così l'aspetto di un elenco ciclico. L'algoritmo ti dirà quindi esattamente quanto è in fondo alla lista A l'unione (la variabile 'mu' secondo la descrizione di Wikipedia).

Inoltre, il valore "lambda" ti dice la lunghezza della lista B e, se vuoi, puoi calcolare la lunghezza della lista A durante l'algoritmo (quando reindirizzi il collegamento NULL).

Forse sto semplificando troppo, ma semplicemente iterare l'elenco più piccolo e utilizzare gli ultimi nodi Linkcome punto di fusione?

Allora, dov'è Data->Link->Link == NULLil punto finale, dando Data->Linkcome punto di fusione (alla fine della lista).

MODIFICARE:

Ok, dalla foto che hai postato, analizzi i due elenchi, il più piccolo per primo. Con l'elenco più piccolo è possibile mantenere i riferimenti al nodo successivo. Ora, quando analizzi la seconda lista, fai un confronto sul riferimento per trovare dove Riferimento [i] è il riferimento su LinkedList [i] -> Link. Questo darà il punto di unione. È ora di spiegare con le immagini (sovrapporre i valori sull'immagine l'OP).

Hai un elenco collegato (riferimenti mostrati di seguito):

A->B->C->D->E

Hai una seconda lista collegata:

1->2->

Con l'elenco unito, i riferimenti sarebbero quindi i seguenti:

1->2->D->E->

Pertanto, mappi il primo elenco "più piccolo" (poiché l'elenco unito, che è quello che stiamo contando ha una lunghezza di 4 e l'elenco principale di 5)

Scorri il primo elenco, mantieni un riferimento di riferimenti.

L'elenco conterrà i seguenti riferimenti Pointers { 1, 2, D, E }.

Passiamo ora al secondo elenco:

-> A - Contains reference in Pointers? No, move on
-> B - Contains reference in Pointers? No, move on
-> C - Contains reference in Pointers? No, move on
-> D - Contains reference in Pointers? Yes, merge point found, break.

Certo, mantieni un nuovo elenco di puntatori, ma non è al di fuori delle specifiche. Tuttavia, il primo elenco viene analizzato esattamente una volta e il secondo elenco verrà analizzato completamente solo se non esiste un punto di unione. Altrimenti, finirà prima (al punto di unione).

Ho testato un caso di unione sul mio FC9 x86_64 e ho stampato ogni indirizzo di nodo come mostrato di seguito:

Head A 0x7fffb2f3c4b0
0x214f010
0x214f030
0x214f050
0x214f070
0x214f090
0x214f0f0
0x214f110
0x214f130
0x214f150
0x214f170


Head B 0x7fffb2f3c4a0
0x214f0b0
0x214f0d0
0x214f0f0
0x214f110
0x214f130
0x214f150
0x214f170

Nota perché avevo allineato la struttura del nodo, quindi quando malloc () un nodo, l'indirizzo è allineato con 16 byte, vedi almeno 4 bit. I bit minimi sono 0, ovvero 0x0 o 000b. Quindi, se anche tu sei nello stesso caso speciale (indirizzo di nodo allineato), puoi usare questi almeno 4 bit. Ad esempio, quando si spostano entrambe le liste dalla testa alla coda, impostare 1 o 2 dei 4 bit dell'indirizzo del nodo in visita, ovvero impostare un flag;

next_node = node->next;
node = (struct node*)((unsigned long)node | 0x1UL);

Nota i flag sopra non influenzeranno l'indirizzo del nodo reale ma solo il valore del puntatore del nodo SALVATO.

Una volta trovato qualcuno che ha impostato i bit flag, il primo nodo trovato dovrebbe essere il punto di unione. al termine, ripristinerai l'indirizzo del nodo cancellando i bit di flag che avevi impostato. mentre una cosa importante è che dovresti stare attento quando iterare (ad esempio node = node-> next) per pulire. ricorda di aver impostato i bit flag, quindi fai in questo modo

real_node = (struct node*)((unsigned long)node) & ~0x1UL);
real_node = real_node->next;
node = real_node;

Poiché questa proposta ripristinerà gli indirizzi di nodo modificati, potrebbe essere considerata come "nessuna modifica".

Può esserci una soluzione semplice ma richiederà uno spazio ausiliario. L'idea è di attraversare un elenco e memorizzare ogni indirizzo in una mappa hash, ora attraversare l'altro elenco e abbinare se l'indirizzo si trova nella mappa hash o meno. Ciascun elenco viene esaminato una sola volta. Non ci sono modifiche a nessun elenco. La lunghezza è ancora sconosciuta. Spazio ausiliario utilizzato: O (n) dove 'n' è la lunghezza del primo elenco attraversato.

questa soluzione itera ogni lista solo una volta ... non è richiesta anche alcuna modifica della lista .. anche se potresti lamentarti dello spazio ..
1) Fondamentalmente si itera in list1 e si memorizza l'indirizzo di ogni nodo in un array (che memorizza il valore int senza segno)
2) Quindi iterate list2 e per l'indirizzo di ogni nodo ---> cercate nell'array che trovate una corrispondenza o meno ... se lo fate allora questo è il nodo che si unisce

//pseudocode
//for the first list
p1=list1;
unsigned int addr[];//to store addresses
i=0;
while(p1!=null){
  addr[i]=&p1;
  p1=p1->next;
}
int len=sizeof(addr)/sizeof(int);//calculates length of array addr
//for the second list
p2=list2;
while(p2!=null){
  if(search(addr[],len,&p2)==1)//match found
  {
    //this is the merging node
    return (p2);
  }
  p2=p2->next;
}

int search(addr,len,p2){
  i=0;  
  while(i<len){
    if(addr[i]==p2)
      return 1;
    i++;
  }
 return 0;
} 

Spero sia una soluzione valida ...

Non è necessario modificare alcun elenco. C'è una soluzione in cui dobbiamo solo attraversare ogni lista una volta.

1. Crea due stack, diciamo stck1 e stck2.
2. Attraversa il primo elenco e invia una copia di ogni nodo che attraversi in stck1.
3. Come il passaggio due, ma questa volta attraversa il 2 ° elenco e invia la copia dei nodi in stck2.
4. Ora, fai un salto da entrambi gli stack e controlla se i due nodi sono uguali, se sì, mantieni un riferimento a loro. In caso contrario, i nodi precedenti che erano uguali sono in realtà il punto di unione che stavamo cercando.

int FindMergeNode(Node headA, Node headB) {
  Node currentA = headA;
  Node currentB = headB;

  // Do till the two nodes are the same
  while (currentA != currentB) {
    // If you reached the end of one list start at the beginning of the other
    // one currentA
    if (currentA.next == null) {
      currentA = headA;
    } else {
      currentA = currentA.next;
    }
    // currentB
    if (currentB.next == null) {
      currentB = headB;
    } else {
      currentB = currentB.next;
    }
  }
  return currentB.data;
}

Ecco una soluzione ingenua, non c'è bisogno di attraversare intere liste.

se il tuo nodo strutturato ha tre campi come

struct node {
    int data;   
    int flag;  //initially set the flag to zero  for all nodes
    struct node *next;
};

diciamo che hai due teste (head1 e head2) che puntano all'inizio di due liste.

Attraversa entrambe le liste allo stesso ritmo e metti la bandiera = 1 (bandiera visitata) per quel nodo,

  if (node->next->field==1)//possibly longer list will have this opportunity
      //this will be your required node. 

Cosa ne pensi di questo:

1. Se puoi attraversare ogni elenco solo una volta, puoi creare un nuovo nodo, attraversare il primo elenco per fare in modo che ogni nodo punti a questo nuovo nodo e attraversare il secondo elenco per vedere se qualche nodo punta al tuo nuovo nodo ( questo è il tuo punto di unione). Se il secondo attraversamento non porta al tuo nuovo nodo, gli elenchi originali non hanno un punto di unione.

2. Se ti è permesso di attraversare le liste più di una volta, puoi attraversare ciascuna lista per trovare la nostra lunghezza e se sono diverse, ometti i nodi "extra" all'inizio della lista più lunga. Quindi attraversa entrambi gli elenchi un passaggio alla volta e trova il primo nodo di fusione.

Passaggi in Java:

1. Crea una mappa.
2. Inizia ad attraversare in entrambi i rami della lista e Metti tutti i nodi attraversati della lista nella mappa usando qualcosa di univoco correlato ai nodi (diciamo ID nodo) come chiave e metti Valori come 1 all'inizio per tutti.
3. Quando arriva la prima chiave duplicata, incrementa il valore per quella chiave (diciamo ora che il suo valore è diventato 2 che è> 1.
4. Ottieni la chiave in cui il valore è maggiore di 1 e dovrebbe essere il nodo in cui si stanno unendo due elenchi.

Possiamo risolverlo efficacemente introducendo il campo "isVisited". Attraversa il primo elenco e imposta il valore "isVisited" su "true" per tutti i nodi fino alla fine. Ora inizia dal secondo e trova il primo nodo in cui flag è true e Boom, è il tuo punto di fusione.

Passaggio 1: trova la lunghezza di entrambi gli elenchi Passaggio 2: Trova il diff e sposta l'elenco più grande con la differenza Passaggio 3: Ora entrambi gli elenchi saranno in una posizione simile. Passaggio 4: scorrere l'elenco per trovare il punto di unione

//Psuedocode
def findmergepoint(list1, list2):
lendiff = list1.length() > list2.length() : list1.length() - list2.length() ? list2.lenght()-list1.lenght()
biggerlist = list1.length() > list2.length() : list1 ? list2  # list with biggest length
smallerlist = list1.length() < list2.length() : list2 ? list1 # list with smallest length


# move the biggest length to the diff position to level both the list at the same position
for i in range(0,lendiff-1):
    biggerlist = biggerlist.next
#Looped only once.  
while ( biggerlist is not None and smallerlist is not None ):
    if biggerlist == smallerlist :
        return biggerlist #point of intersection


return None // No intersection found

int FindMergeNode(Node *headA, Node *headB)
{
    Node *tempB=new Node;
    tempB=headB;
   while(headA->next!=NULL)
       {
       while(tempB->next!=NULL)
           {
           if(tempB==headA)
               return tempB->data;
           tempB=tempB->next;
       }
       headA=headA->next;
       tempB=headB;
   }
    return headA->data;
}

Usa mappa o dizionario per memorizzare il valore degli indirizzi rispetto al nodo. se l'indirizzo già letto esiste nella mappa / dizionario, il valore della chiave è la risposta. L'ho fatto:

int FindMergeNode(Node headA, Node headB) {

Map<Object, Integer> map = new HashMap<Object, Integer>();

while(headA != null || headB != null)
{
    if(headA != null && map.containsKey(headA.next))
    {
        return map.get(headA.next);
    }

    if(headA != null && headA.next != null)
    {
         map.put(headA.next, headA.next.data);
         headA = headA.next;
    }

    if(headB != null && map.containsKey(headB.next))
    {
        return map.get(headB.next);
    }

    if(headB != null && headB.next != null)
    {
        map.put(headB.next, headB.next.data);
        headB = headB.next;
    }
}

return 0;
}

Soluzione di complessità AO (n). Ma basato su un'ipotesi.

l'ipotesi è: entrambi i nodi hanno solo numeri interi positivi.

logica: rende negativo tutto il numero intero di lista1. Quindi esplora list2, finché non ottieni un numero intero negativo. Una volta trovato => prendilo, cambia il segno di nuovo in positivo e torna.

static int findMergeNode(SinglyLinkedListNode head1, SinglyLinkedListNode head2) {

    SinglyLinkedListNode current = head1; //head1 is give to be not null.

    //mark all head1 nodes as negative
    while(true){
        current.data = -current.data;
        current = current.next;
        if(current==null) break;
    }

    current=head2; //given as not null
    while(true){
        if(current.data<0) return -current.data;
        current = current.next;
    }

}

Possiamo usare due puntatori e muoverci in modo tale che se uno dei puntatori è nullo lo indichiamo all'inizio dell'altra lista e lo stesso per l'altra, in questo modo se le lunghezze della lista sono diverse si incontreranno nel secondo passaggio . Se la lunghezza di lista1 è n e lista2 è m, la loro differenza è d = abs (nm). Copriranno questa distanza e si incontreranno nel punto di unione.
Codice:

int findMergeNode(SinglyLinkedListNode* head1, SinglyLinkedListNode* head2) {
    SinglyLinkedListNode* start1=head1;
    SinglyLinkedListNode* start2=head2;
    while (start1!=start2){
        start1=start1->next;
        start2=start2->next;
        if (!start1)
        start1=head2;
        if (!start2)
        start2=head1;
    }
    return start1->data;
}

Puoi aggiungere i nodi di list1a un hashset e il ciclo attraverso il secondo e se un qualsiasi nodo di list2è già presente nel set. Se sì, allora quello è il nodo di unione

static int findMergeNode(SinglyLinkedListNode head1, SinglyLinkedListNode head2) {
    HashSet<SinglyLinkedListNode> set=new HashSet<SinglyLinkedListNode>();
    while(head1!=null)
    {
        set.add(head1);
        head1=head1.next;
    }
    while(head2!=null){
        if(set.contains(head2){
            return head2.data;
        }
    }
    return -1;
}

Soluzione utilizzando javascript

var getIntersectionNode = function(headA, headB) {
    
    if(headA == null || headB == null) return null;
    
    let countA = listCount(headA);
    let countB = listCount(headB);
    
    let diff = 0;
    if(countA > countB) {

        diff = countA - countB;
        for(let i = 0; i < diff; i++) {
            headA = headA.next;
        }
    } else if(countA < countB) {
        diff = countB - countA;
        for(let i = 0; i < diff; i++) {
            headB = headB.next;
        }
    }

    return getIntersectValue(headA, headB);
};

function listCount(head) {
    let count = 0;
    while(head) {
        count++;
        head = head.next;
    }
    return count;
}

function getIntersectValue(headA, headB) {
    while(headA && headB) {
        if(headA === headB) {
            return headA;
        }
        headA = headA.next;
        headB = headB.next;
    }
    return null;
}

Se è consentita la modifica dell'elenco collegato,

1. Quindi rendi nulli i puntatori del nodo successivo di tutti i nodi della lista 2.
2. Trova il valore dei dati dell'ultimo nodo della lista 1. Questo ti darà il nodo intersecante in un singolo attraversamento di entrambe le liste, senza "logica hi fi".