Échange de nœuds adjacents dans une liste liée

Question

J'ai des problèmes d'échange de nœuds adjacents dans une liste liée.

par ex: entrée: 1-> 2-> 3-> 4-> 5-> null sortie : 2-> 1-> 4-> 3-> 5-> null

bool swapAdjacent(node** head) 
{ 

//1->2->3->4->null 

//2->1->4->3->null 
if(head==NULL) 
return 0; 
node* current = *head; 
*head = (*head)->next ; 
node* prev = NULL; 
cout<<"head val "<<(*head)->data <<endl; 
node* temp; 
while(current!=NULL&&current->next!=NULL) 
{ 
    temp = current->next ; //1s pointer points to 2 
    current->next = temp->next ; // 1s pointer point to 3 
    temp ->next = current; //2s pointer shud point to 1 
    prev = current; 
    current = current->next ; 
    //cout<<"data " <<current->data <<endl; 

    if(current!=NULL) 
    prev->next = current->next ; 



} 

return 1; 
} 

Mon code ne fonctionne pas lorsqu'il y a un nombre impair de noeuds. Comment régler ceci ?

Answer 1

Pourquoi si compliqué?

int swapAdjacent(node** head) { 
    if (!*head || !(*head)->next) 
    return 0; 
    node* const sw = (*head)->next; 
    (*head)->next = sw->next; 
    sw->next = *head; 
    *head = sw; 
    swapAdjacent(&(sw->next->next)); 
    return 1; 
} 

Édition: modification de la valeur de retour.

Answer 2

Je ne sais pas ce qui ne va pas avec votre code, mais je voudrais l'aborder en montrant l'état de la liste de chaque passage dans la boucle:

void printList(node* head) 
{ 
    int cntr = 1; 

    while (head != NULL) 
    { 
     printf("(Node: %d. Name: %s) --> ", cntr, head->name); 
     head = head->next; 
    } 
} 

Pour cela, assurez-vous que chaque nœud a name, régler sur "1", "2", etc. Ensuite, imprimez l'état de la liste à chaque passage, peut-être même à chaque étape! Et vous devriez voir ce qui ne va pas.

Answer 3

#include<iostream.h> 
#include<stdlib.h> 
#include<conio.h> 
struct s_sll 
{ 
    int info; 
    struct s_sll *link; 
}; 
typedef s_sll node; 
class sll 
{ 
    public: 
     static int cou; 
     node *first; 
     sll() 
     { 
     first=NULL; 
     cou++; 
     } 
     node*create_node(int val); 
     node*del_val(); 
     void disp(); 
     void swap_adjcent(); 
     ~sll() 
     { 
     delete first; 
     cou--; 
     } 
}; 
void disp_all(sll **); 
void despose(sll **); 
int sll::cou=0; 
void sll::swap_adjcent() 
{ 
    node *temp,*a,*b; 
    a=first; 
    b=a->link; 
    temp=b->link; 
    a->link=temp->link; 
    b->link=a; 
    first=b; 
    while(b!=NULL) 
    { 
     a=temp; 
     b=temp->link; 
     temp=b->link; 
     if(temp->link!=NULL) 
     { 
     a->link=temp->link; 
     b->link=a; 
     a=temp->link; 
     } 
     else 
     { 
     a->link=temp; 
     b->link=a; 
     } 
    } 
    delete temp; 
} 
node* sll::create_node(int val) 
{ 
    node *save,*temp; 
    temp = new s_sll; 
    temp->info=val; 
    temp->link=NULL; 
    if(first==NULL) 
     first=temp; 
    else 
    { 
     save=first; 
     while(save->link!=NULL) 
      save=save->link; 
     save->link=temp; 
    } 
    return first; 
} 

Answer 4

public static node adjacent_reversal(node head) 
{ 
    node temp = null; 
    if(head == null) 
     return null; 
    if(head.next == null) 
    { 
     head.next = null; 
     return head; 
    } 
    temp = adjacent_reversal(head.next.next); 
    node temp1 = head.next; 
    head.next.next = head; 
    head.next = temp; 
    return temp1; 
} 

Answer 5

vous prenez deux pointeurs ... des points Initialement p1 au 1er noeud et p2 au 2ème noeud

et itérer dans une boucle jusqu'à ce que le point p2 null ... et augmentation de la boucle doit être

p1=(p1->next)->next; 
p2=(p2->next)->next; 
//swap the node pointed by these two pointers .. 

cela fonctionnera très bien ..