Swapping nodes in a linked list means exchanging the positions of two nodes in the list. For example, if we have a linked list 1 -> 2 -> 3 -> 4 -> 5 and we want to swap the second and fourth nodes, the result will be 1 -> 4 -> 3 -> 2 -> 5.

Swapping nodes can be a bit tricky in singly linked lists because we need to update the pointers of the nodes before and after the swapped nodes. However, it is relatively easier in doubly or circular linked lists because we have access to both the previous and next nodes of each node.

Here is a nonrecursive solution for swapping two nodes in a doubly linked list:

``````function swapNodes(node1, node2):
if node1 is the same as node2:
return

tempPrev1 = node1.prev
tempNext1 = node1.next
tempPrev2 = node2.prev
tempNext2 = node2.next

if tempNext1 is the same as node2:
# node1 is immediately before node2
node1.prev = node2
node1.next = tempNext2
node2.prev = tempPrev1
node2.next = node1
tempNext2.prev = node1
tempPrev1.next = node2
elif tempPrev2 is the same as node1:
# node2 is immediately before node1
node2.prev = node1
node2.next = tempNext1
node1.prev = tempPrev2
node1.next = node2
tempNext1.prev = node2
tempPrev2.next = node1
else:
node1.prev = tempPrev2
node1.next = tempNext2
node2.prev = tempPrev1
node2.next = tempNext1
tempNext2.prev = node1
tempPrev1.next = node2
tempNext1.prev = node2
tempPrev2.next = node1
``````

In this pseudocode, we first check if the two nodes are the same. If they are, we simply return. Then, we store the previous and next nodes of both nodes in temporary variables. We need these variables because we’ll be updating the pointers of the nodes, and we don’t want to lose the connections.

Next, we check if the two nodes are adjacent. If they are, we update the pointers of the nodes accordingly. Otherwise, we update the pointers of all the relevant nodes.

Here is a recursive solution for swapping two nodes in a doubly linked list:

``````function swapNodes(node1, node2):
if node1 is the same as node2:
return

if node1.next is the same as node2:
# node1 is immediately before node2
tempPrev = node1.prev
tempNext2 = node2.next
node1.prev = node2
node1.next = tempNext2
node2.prev = tempPrev
node2.next = node1
tempNext2.prev = node1
if tempPrev is not None:
tempPrev.next = node2
elif node2.next is the same as node1:
# node2 is immediately before node1
tempPrev = node2.prev
tempNext1 = node1.next
node2.prev = node1
node2.next = tempNext1
node1.prev = tempPrev
node1.next = node2
tempNext1.prev = node2
if tempPrev is not None:
tempPrev.next = node1
else:
tempPrev1 = node1.prev
tempNext1 = node1.next
tempPrev2 = node2.prev
tempNext2 = node2.next
node1.prev = tempPrev2
node1.next = tempNext2
node2.prev = tempPrev1
node2.next = tempNext1
if tempPrev1 is not None:
tempPrev1.next = node2
if tempPrev2 is not None:
tempPrev2.next = node1
if tempNext1 is not None:
tempNext1.prev = node2
if tempNext2 is not None:
tempNext2.prev = node1

swapNodes(node2, node1.next)
``````

This recursive pseudocode works similarly to the iterative pseudocode for a double linked list. However, instead of using loops, we use recursive function calls to traverse the list and swap nodes. The function swaps the current pair of nodes and then calls itself with the next pair of nodes.

Note that the function assumes that the linked list has a `prev` pointer in addition to the `next` pointer.

Note that the above pseudocode assumes that the linked list has a `prev` pointer in addition to the `next` pointer. If the linked list is singly linked, we would need to traverse the list to find the nodes before the nodes we want to swap, in order to update their pointers.

Here is a nonrecursive solution for swapping a node in a singly linked list

``````function swapNodes(node1, node2, head):
if node1 is the same as node2:

prev1 = None
while curr1 is not None and curr1 is not node1:
prev1 = curr1
curr1 = curr1.next

prev2 = None
while curr2 is not None and curr2 is not node2:
prev2 = curr2
curr2 = curr2.next

if curr1 is None or curr2 is None:

if prev1 is not None:
prev1.next = curr2
else:

if prev2 is not None:
prev2.next = curr1
else:

temp = curr1.next
curr1.next = curr2.next
curr2.next = temp

``````

In this pseudocode, we first check if the two nodes are the same. If they are, we simply return the head of the list. Then, we traverse the list to find the nodes before the nodes we want to swap. We need these nodes in order to update their `next` pointers.

Next, we check if either of the nodes is not found in the list. If that’s the case, we simply return the head of the list.

If both nodes are found, we update the `next` pointers of the nodes before the nodes we want to swap. If the node to be swapped is the first node, we update the head of the list. Then, we swap the `next` pointers of the nodes to complete the swap.

Finally, we return the head of the list.

Here is a recursive solution for swapping a node in a singly linked list

``````function swapNodes(node1, node2, head):
if node1 is the same as node2:

if head is the same as node1:
elif head is the same as node2:

prev1 = None
while curr1 is not None and curr1 is not node1:
prev1 = curr1
curr1 = curr1.next

prev2 = None
while curr2 is not None and curr2 is not node2:
prev2 = curr2
curr2 = curr2.next

if curr1 is None or curr2 is None:

if prev1 is not None:
prev1.next = node2
if prev2 is not None:
prev2.next = node1

temp = node1.next
node1.next = node2.next
node2.next = temp

if prev1 is None:
elif prev2 is None:

Note that the function assumes that the nodes in the linked list have a `next` pointer that points to the next node in the list. It also takes the `head` of the list as an argument and returns the new head after swapping the nodes.