Compte tenu d'une liste liée des nombres. Échanger tous les 2 liens adjacents

@dkamins: vous changez les valeurs mais dans ce type de questions, les intervieweurs demandent généralement un pointeur shuffling.

Ma tentative de problème: strong> p>

void swap (struct list **list1)
{
    struct list *cur, *tmp, *next;
    cur = *list1;

    if(!cur || !cur->next)
              return;

    *list1 = cur->next;

    while(cur && cur->next)
    {
              next = cur->next;
              cur->next = next->next;
              tmp = cur->next;
              next->next = cur;
              if(tmp && tmp->next)
                  cur->next = cur->next->next;
              cur = tmp;                                  
    }
}

ici il est en complète java runnable. Ceci est purement de jeu de pointeur. xxx

(suite ...) xxx

( Voir la sortie complète )

J'ai adapté la solution @DKamins, d'une certaine manière. Au lieu de prendre un pointeur sur un pointeur, je retourne la nouvelle tête code>. Je l'ai également renforcé.

n = 3
tmp = 3
n = 5
tmp->next = NULL (3 -> NULL)
n->next = 3  (5 -> 3)
n = NULL

Je suppose que cela rendra plus efficace, il serait préférable de prendre un autre argument n dans la fonction. Ce n est utilisé pour le compte, c'est-à-dire après combien de compter les nœuds doivent être modifiés. dans la case ci-dessus n = 2. Et ensuite continuer sur iterating jusqu'à ce que vous appuyez sur la N et utilisez la liaison de liaison nominale inversée ou une liaison de liaison de liaison inversée récursive à l'algo pour le faire.

Reverselinkinkinkinkinkinkinkink (Struct Noode * Tête, INT N) { Si (tête == null || null <= 0) retour; xxx

}

2 -> (1,4) -> 3  -> NULL

Jetez un oeil à cette solution C ++:

public void exchangeAdjElements(){
    LLMain backup=current.next;
    LLMain temp = current.next;
    LLMain previous=current;
    while(current!=null && current.next!=null){
        previous.next=current.next;
        current.next=temp.next;
        temp.next=current;
        if(current.next!=null){
            previous=current;
            current=current.next;
            temp=current.next;
        }
    }
    current=backup;
}

Voici mon code C ++: il retournera le pointeur sur la liste liée à échange d'échantillonnage xxx

Slist statique privé SwapalternateSelements (Slist n) {

    if(n == null)
        return n;
    SList head = swap(n);
    SList tail = head;

    while(tail == null || tail.next != null){
        tail.next.next = swap(tail.next.next);
        tail = tail.next.next;
    }

    return head;

}

private static SList swap(SList n){

    if(n.next == null || n==null){
        return n;
    }
    SList current = n.next;
    SList next = current.next;
    n.next = next;
    current.next = n;
    return current;

}

Ici, "Head" est le pointeur du premier nœud de la liste liée et la fonction renvoie le nouveau pointeur de tête.

node* swapPairs(node *head) {
if(head==NULL || head->next==NULL) {
    return head;
}

node *ptr1=head->next;
node *ptr2=ptr1->next;
ptr1->next=head;
head->next=swapPairs(ptr2);
return ptr1;

J'ai essayé de le résoudre et j'ai ici la solution.

public Node swapAdjacentNodes() {
    if (head == null)
        return null;
    if (head.nextNode == null)
        return head;
    Node previous = null;
    Node current = head;
    Node next = head.nextNode;
    while (next != null && next != current) {
        current.nextNode = next.nextNode;
        next.nextNode = current;
        if (previous == null) {
            previous = next;
            head = previous;
            previous = previous.nextNode;
        } else {
            previous.nextNode = next;
            previous = previous.nextNode.nextNode;
        }
        current = current.nextNode;
        if (current == null)
            break;
        next = next.nextNode.nextNode.nextNode;

    }
    return head;

}

Voici ma fonction C pour échanger des liens de nœuds alternatifs dans la liste liée. J'ai inclus des commentaires dans le code. Pour une meilleure compréhension, prenez un exemple et parcourez les étapes en faisant des diagrammes à l'aide de stylo et de papier. XXX

Ma prise sur la solution: -

public Node exchangeAdjacentNodes(Node head){
     Node curr = head;
     Node temp=null,next=null;
     if(curr==null||curr.next==null){
         return curr;
     Node head = curr.next;
     while(curr!=null && curr.next!=null){
           next = curr.next;
           curr.next=next.next;
           temp = curr.next;
           next.next = curr;
           if(temp!=null && temp.next!=null)
                 curr.next = curr.next.next;
           curr=temp;
      }
      return head;
}

public void swapAdjacent() {
    temp = head;
    while (temp != null && temp.next != null) {
        Object tem = temp.val;
        temp.val = temp.next.val;
        temp.next.val = (Object) tem;
        temp = temp.next.next;
    }
}

Cela pourrait aider: Public statique Void Main (String [] args) {

    String arr[] = { "a", "b", "c", "d", "e", "f" };
    int i = 0;
    int k = 1;
    String temp;

    while (k <= arr.length - 1 && arr[i] != null && arr[k] != null) {

        temp = arr[i];
        arr[i] = arr[k];
        arr[k] = temp;

        k++;
        i = k;
        k++;
    }
    for (int j = 0; j < arr.length; j++) {

        System.out.print(arr[j]+"->");
    }

}
// Input  ->  a->b->c->d->e->f->
// Output -> b->a->d->c->f->e->

Code C pour échanger adjacent xxx