用于对给定链接列表的成对交换元素的 Javascript 程序

给定一个单链表，编写一个函数来成对交换元素。

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

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

Input: 1->NULL 
Output: 1->NULL

例如，如果链表是 1->2->3->4->5，则函数应将其更改为 2->1->4->3->5，如果链表是函数应将其更改为。

方法1（迭代）：
从头节点开始，遍历列表。在遍历每个节点的交换数据及其下一个节点的数据时。
下面是上述方法的实现：

Javascript

// JavaScript program to pairwise swap
// elements of a linked list
 
// head of list
var head;
 
// Linked list Node
class Node
{
    constructor(val)
    {
        this.data = val;
        this.next = null;
    }
}
 
function pairWiseSwap()
{
    var temp = head;
 
    /* Traverse only till there are
       atleast 2 nodes left */
    while (temp != null &&
           temp.next != null)
    {
        // Swap the data
        var k = temp.data;
        temp.data = temp.next.data;
        temp.next.data = k;
        temp = temp.next.next;
    }
}
 
// Utility functions
// Inserts a new Node at front
// of the list.
function push(new_data)
{
    /* 1 & 2: Allocate the Node &
              Put in the data */
    var new_node = new Node(new_data);
 
    // 3. Make next of new Node as head
    new_node.next = head;
 
    // 4. Move the head to point to
    // new Node
    head = new_node;
}
 
// Function to print linked list
function printList()
{
    var temp = head;
    while (temp != null)
    {
        document.write(temp.data + " ");
        temp = temp.next;
    }
    document.write("<br/>");
}
 
// Driver code
/ * Created Linked List
    1->2->3->4->5 */
push(5);
push(4);
push(3);
push(2);
push(1);
 
document.write(
"Linked List before calling pairWiseSwap() <br/>");
printList();
 
pairWiseSwap();
 
document.write(
"Linked List after calling pairWiseSwap()<br/> ");
printList();
// This code is contributed by todaysgaurav

输出：

Linked list before calling pairWiseSwap()
1 2 3 4 5 
Linked list after calling pairWiseSwap()
2 1 4 3 5 

时间复杂度：O(n)，因为我们正在使用 while 循环遍历大小为 N 的链表。

辅助空间：O(1)，因为我们没有使用任何额外的空间。

方法 2（递归）：
如果链接列表中有 2 个或超过 2 个节点，则交换前两个节点并递归调用列表的其余部分。
下图是上述方法的试运行：

下面是上述方法的实现：

Javascript

/* Recursive function to pairwise swap
   elements of a linked list */
function pairWiseSwap(head)
{
    /* There must be at-least two nodes
       in the list */
    if (head != null &&
        head.next != null)
    {
        /* Swap the node's data with data
           of next node */
        swap(head.data, head.next.data);
  
        /* Call pairWiseSwap() for rest of
           the list */
        pairWiseSwap(head.next.next);
    }
}
// This code is contributed by avanitrachhadiya2155

时间复杂度：O(n)，因为我们正在使用递归遍历大小为 N 的链表。

辅助空间：O(1)，因为我们没有使用任何额外的空间。
那里提供的解决方案交换节点的数据。如果数据包含很多字段，就会有很多交换操作。有关更改链接而不是交换数据的实现，请参阅此内容。

有关详细信息，请参阅有关给定链表的成对交换元素的完整文章！