Programme JavaScript pour l'échange par paires d'éléments d'une liste chaînée donnée

Dans ce didacticiel, nous apprendrons un programme JavaScript permettant d'échanger par paires des éléments d'une liste chaînée donnée. Une opération courante sur les listes chaînées consiste à échanger les éléments adjacents par paires. Cette opération est utile dans divers scénarios, comme la réorganisation des données, la réorganisation des éléments dans un ordre spécifique ou l'optimisation de certains algorithmes. De plus, nous nous concentrerons sur la résolution du problème de l’échange par paires d’éléments dans une liste chaînée donnée à l’aide de JavaScript. Nous proposerons une approche étape par étape pour implémenter l’algorithme, en expliquant la logique et le code qui le sous-tend. À la fin de ce didacticiel, vous comprendrez clairement comment implémenter un programme JavaScript pour échanger des éléments d'une liste chaînée par paires, ainsi qu'un exemple de code et des instructions pour chaque étape.

Plongeons dans la solution à ce problème en JavaScript !

Énoncé du problème

À partir d'une liste chaînée, la tâche consiste à implémenter un programme JavaScript qui échange des éléments par paires. En d’autres termes, les éléments occupant des positions consécutives dans la liste chaînée sont échangés les uns avec les autres. Si le nombre d'éléments dans la liste chaînée est impair, le dernier élément reste inchangé. Le programme doit renvoyer la tête modifiée de la liste chaînée.

Exemple

Exemple 1 -

Input: 1 -> 2 -> 3 -> 4 -> 5
Output: 2 -> 1 -> 4 -> 3 -> 5

Explication- Dans la liste chaînée donnée, les éléments aux positions 1 et 2 (1 et 2 sont des index 0) sont échangés et le résultat est 2 -> 1 -> 3 -> 4 -> 5. Ensuite, les positions sont échangés. Pour les éléments 3 et 4, le résultat est 2 -> 1 -> 4 -> 3 -> 5.

Exemple 2 -

Input: 10 -> 20 -> 30 -> 40 -> 50 -> 60 -> 70
Output: 20 -> 10 -> 40 -> 30 -> 60 -> 50 -> 70

Explication− Dans la liste chaînée donnée, les éléments aux positions 1 et 2 sont échangés, et le résultat est 20 -> 10 -> 30 -> 40 -> 50 -> 60 -> 70. Ensuite, positions 3 et Les éléments de 4 sont échangés, et le résultat est 20 -> 10 -> 40 -> 30 -> 50 -> 60 -> 70. Enfin, les éléments aux positions 5 et 6 sont échangés, ce qui donne 20 -> 10 -> 40 -> 30 -> 60 -> 50 -> 70.

Maintenant, comprenons l'algorithme pour implémenter cet énoncé de problème.

Algorithme

• Créez une fonction appelée pairwiseSwap(head) qui prend la tête de la liste chaînée en entrée.

• Initialisez une variable temporaire temp pour stocker le nœud actuel et définissez-le en tête de la liste chaînée.

• Parcourez la liste chaînée avec un pas de 2, c'est-à-dire déplacez deux nœuds à la fois.

• Pour chaque paire de nœuds, échangez leurs valeurs.

• Passez à la paire de nœuds suivante.

• Continuez ce processus jusqu'à ce que vous atteigniez la fin de la liste chaînée ou qu'il n'y ait plus de paires à échanger.

• Renvoyer l'en-tête de liste chaînée modifié.

Donc, après avoir compris l'algorithme, implémentons-le à l'aide d'un exemple, dans lequel nous l'implémentons à l'aide de JavaScript.

Exemple : implémenté à l'aide de JavaScript

Le programme ci-dessus implémente l'échange par paires d'éléments dans une liste chaînée donnée. Il utilise la classe Node pour représenter les nœuds d'une liste chaînée et utilise la fonction pairwiseSwap() pour échanger les valeurs des nœuds adjacents par paires. Le programme crée d'abord une liste chaînée avec un ensemble d'éléments donné, affiche la liste chaînée d'origine, effectue un échange par paire à l'aide de la fonction pairwiseSwap(), puis affiche la liste chaînée mise à jour contenant les éléments échangés.

Entrée : Liste chaînée originale : 1 -> 2 -> 3 -> 4 -> 5 -> null

Résultat attendu : liste chaînée après échange par paire : 2 -> 1 -> 4 -> 3 -> 5 -> null

class Node {
   constructor(value) {
      this.value = value;
      this.next = null;
   }
}
function pairwiseSwap(head) {
   let temp = head;
   while (temp !== null && temp.next !== null) {
      // Swap values of current and next nodes
      let tempVal = temp.value;
      temp.value = temp.next.value;
      temp.next.value = tempVal;
      // Move to the next pair of nodes
      temp = temp.next.next;
   }
   return head;
}

// Linked list with odd number of elements
let head = new Node(1);
let node2 = new Node(2);
let node3 = new Node(3);
let node4 = new Node(4);
let node5 = new Node(5);
head.next = node2;
node2.next = node3;
node3.next = node4;
node4.next = node5;
console.log("Original Linked List:");
let temp = head;
while (temp !== null) {
   process.stdout.write(temp.value + " -> ");
   temp = temp.next;
}
console.log("null");
head = pairwiseSwap(head);
console.log("Linked List after Pairwise Swapping:");
temp = head;
while (temp !== null) {
   process.stdout.write(temp.value + " -> ");
   temp = temp.next;
}
console.log("null");

Conclusion

Pour résumer, le programme JavaScript fourni dans ce tutoriel démontre une solution efficace pour l'échange par paires d'éléments dans une liste chaînée donnée. L'algorithme parcourt une liste chaînée, en échangeant les éléments adjacents par paires, ce qui donne lieu à une liste chaînée mise à jour avec les éléments échangés. Cette solution est utile dans divers scénarios où l'échange d'éléments est requis lors des opérations de liste chaînée. En implémentant ce programme, nous pouvons facilement effectuer un échange par paire d'éléments dans une liste chaînée à l'aide de JavaScript.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!