Swap Kth node from beginning with Kth node from end in the given Linked List

#include <bits stdc++.h="">
using namespace std;

/* Linked List Node structure */
struct Node {
    int data;
    Node* next;
};

/* Using this function we will insert a new node at the head of linked list */
void push_node(struct Node** head, int data)
{
    struct Node* new_node = (struct Node*)malloc(sizeof(struct Node));
    new_node->data = data;
    new_node->next = (*head);
    (*head) = new_node;
}

/* Using this function we will print the linked list */
void printLinkedList(struct Node* node)
{
    while (node != NULL) {
        cout << node->data << " ";
        node = node->next;
    }
    cout << endl;
}

/* Using this function we will calculate the length of linked list */
int lenLinkedList(struct Node* for_len)
{
    int count = 0;
    while (for_len != NULL) {
        count++;
        for_len = for_len->next;
    }
    return count;
}

/* Using this function we will swap the Kth node from beginning with the Kth node from end */
void swapKthnode(struct Node** head, int K)
{
    int len = lenLinkedList(*head);

    if (len < K)
        return;

    if (2 * K - 1 == len)
        return;

    Node* x = *head;
    Node* x_prev = NULL;
    for (int i = 1; i < K; i++) {
        x_prev = x;
        x = x->next;
    }

    Node* y = *head;
    Node* y_prev = NULL;
    for (int i = 1; i < len - K + 1; i++) {
        y_prev = y;
        y = y->next;
    }

    if (x_prev)
        x_prev->next = y;

    if (y_prev)
        y_prev->next = x;

    Node* temp = x->next;
    x->next = y->next;
    y->next = temp;

    if (K == 1)
        *head = y;
    if (K == len)
        *head = x;
}

int main()
{
  Node* head = NULL;
  push_node(&head,10);
  push_node(&head,8);
  push_node(&head,6);
  push_node(&head,4);
  push_node(&head,2);
  cout << "Our original Linked List: ";
  printLinkedList(head);
  int K = 2;
  swapKthnode(&head,K);
  cout<< "Linked List after swapping: ";
  printLinkedList(head);
    return 0;
}

class Node 
{
	int data;
	Node next;
	Node(int d)
	{
		data = d;
		next = null;
	}
}
class SwapKth 
{
	Node head;
	void push(int new_data)
	{
		Node new_node = new Node(new_data);
		new_node.next = head;
		head = new_node;
	}
	void printList()
	{
		Node node = head;
		while (node != null) {
			System.out.print(node.data + " ");
			node = node.next;
		}
		System.out.println("");
	}
	/* Utility function for calculating length of linked list */
	int countNodes()
	{
		int count = 0;
		Node s = head;
		while (s != null) {
			count++;
			s = s.next;
		}
		return count;
	}
	/* Function for swapping kth nodes from
	both ends of linked list */
	void swapKth(int k)
	{
		// Count nodes in linked list
		int n = countNodes();

		// Check if k is valid
		if (n < k)
			return;

		// If x (kth node from start) and
		// y(kth node from end) are same
		if (2 * k - 1 == n)
			return;

		// Find the kth node from beginning of linked list.
		// We also find previous of kth node because we need
		// to update next pointer of the previous.
		Node x = head;
		Node x_prev = null;
		for (int i = 1; i < k; i++) {
			x_prev = x;
			x = x.next;
		}

		// Similarly, find the kth node from end and its
		// previous. kth node from end is (n-k+1)th node
		// from beginning
		Node y = head;
		Node y_prev = null;
		for (int i = 1; i < n - k + 1; i++) {
			y_prev = y;
			y = y.next;
		}

		// If x_prev exists, then new next of it will be y.
		// Consider the case when y->next is x, in this case,
		// x_prev and y are same. So the statement
		// "x_prev->next = y" creates a self loop. This self
		// loop will be broken when we change y->next.
		if (x_prev != null)
			x_prev.next = y;

		// Same thing applies to y_prev
		if (y_prev != null)
			y_prev.next = x;

		// Swap next pointers of x and y. These statements
		// also break self loop if x->next is y or y->next
		// is x
		Node temp = x.next;
		x.next = y.next;
		y.next = temp;

		// Change head pointers when k is 1 or n
		if (k == 1)
			head = y;

		if (k == n)
			head = x;
	}
	// Driver code to test above
	public static void main(String[] args)
	{
		SwapKth llist = new SwapKth();
		for (int i = 8; i >= 1; i--)
			llist.push(i);

		System.out.print("Original linked list: ");
		llist.printList();
		System.out.println("");

		for (int i = 1; i < 9; i++) {
			llist.swapKth(i);
			System.out.println("Modified List for k = " + i);
			llist.printList();
			System.out.println("");
		}
	}
}

class Node:
	def __init__(self, data, next = None):
		self.data = data
		self.next = next
	
class LinkedList:

	def __init__(self, *args, **kwargs):
		self.head = Node(None)
	def push(self, data):
		node = Node(data)
		node.next = self.head
		self.head = node
	
	def printList(self):
		node = self.head
		while node.next is not None:
			print(node.data, end = " ")
			node = node.next
	
	def countNodes(self):
		count = 0
		node = self.head
		while node.next is not None:
			count += 1
			node = node.next
		return count
	
	def swapKth(self, k):

		n = self.countNodes()

		if n<k:
			return

		if (2 * k - 1) == n:
			return

		x = self.head
		x_prev = Node(None)
		for i in range(k - 1):
			x_prev = x
			x = x.next

		y = self.head
		y_prev = Node(None)
		for i in range(n - k):
			y_prev = y
			y = y.next

		if x_prev is not None:
			x_prev.next = y

		if y_prev is not None:
			y_prev.next = x
		
		temp = x.next
		x.next = y.next
		y.next = temp

		if k == 1:
			self.head = y
		
		if k == n:
			self.head = x

llist = LinkedList()
llist.push(10)
llist.push(8)
llist.push(6)
llist.push(4)
llist.push(2)

print("Our original Linked List:", end = " ")
llist.printList()

llist.swapKth(2)
print("\nLinked List after swapping:", end = " ")
llist.printList()
print("\n")