 GeeksforGeeks App
Open App Browser
Continue

# Javascript program to swap two numbers without using temporary variable

Given two variables, x, and y, swap two variables without using a third variable. Method 1 (Using Arithmetic Operators):

Example 1: The idea is to get a sum in one of the two given numbers. The numbers can then be swapped using the sum and subtraction from the sum.

## Javascript

 ``

Output:

```Before Swapping: x = 10, y = 5
After Swapping: x = 5, y = 10```

Time Complexity: O(1).
Auxiliary Space: O(1).

Example 2: Multiplication and division can also be used for swapping.

## Javascript

 ``

Output:

```Before Swapping: x = 10, y = 5
After Swapping: x = 5, y = 10```

Time Complexity: O(1).
Auxiliary Space: O(1).

Method 2 (Using Bitwise XOR):
The bitwise XOR operator can be used to swap two variables. The XOR of two numbers x and y returns a number that has all the bits as 1 wherever bits of x and y differ. For example, XOR of 10 (In Binary 1010) and 5 (In Binary 0101) is 1111, and XOR of 7 (0111) and 5 (0101) is (0010).

Example: Below is the example that will illustrate the swap two numbers using Bitwise XOR Method:

## Javascript

 ``

Output:

```Before Swapping: x = 10, y = 5
After Swapping: x = 5, y = 10```

Time Complexity: O(1).
Auxiliary Space: O(1).

Problems with the above methods:
1: The multiplication and division-based approach doesn’t work if one of the numbers is 0 as the product becomes 0 irrespective of the other number.
2: Both Arithmetic solutions may cause an arithmetic overflow. If x and y are too large, addition and multiplication may go out of the integer range.
3: When we use pointers to variable and make a function swap, all the above methods fail when both pointers point to the same variable. Let’s take a look at what will happen in this case if both are pointing to the same variable.

```// Bitwise XOR based method
x = x ^ x; // x becomes 0
x = x ^ x; // x remains 0
x = x ^ x; // x remains 0
// Arithmetic based method
x = x + x; // x becomes 2x
x = x - x; // x becomes 0
x = x - x; // x remains 0```

Example 1: Let us see the following program:

## Javascript

 ``

Output:

```Before swap(&x, &x): x = 10
After swap(&x, &x): x = 0```

Time Complexity: O(1).
Auxiliary Space: O(1).

Example 2: Swapping a variable with itself may be needed in many standard algorithms. For example, see this implementation of QuickSort where we may swap a variable with itself. The above problem can be avoided by putting a condition before swapping.

## Javascript

 ``

Output:

```Before swap(&x , &x) : x = 10
After swap(&x , &x) : x = 10```

Time Complexity: O(1).
Auxiliary Space: O(1).

Method 3 (A mixture of bitwise operators and arithmetic operators):
The idea is the same as discussed in Method 1 but uses Bitwise addition and subtraction for swapping.

Example: Below is the implementation of the above approach.

## Javascript

 ``

Output:

```Before swapping: a = 5, b = 10
After swapping: a = 10, b = 5```

Time Complexity: O(1).
Auxiliary Space: O(1), since no extra space has been taken.

Method 4 (One Line Expression): We can write only one line to swap two numbers.

• x = x ^ y ^ (y = x);
• x = x + y – (y = x);
• x = (x * y) / (y = x);
• x , y = y, x (In Python)

Example: Below is the implementation of the above approach.

## Javascript

 ``

Output:

```Before Swapping: x = 10, y = 5
After Swapping: x = 10, y = 5```

Time Complexity: O(1).
Auxiliary Space: O(1).

My Personal Notes arrow_drop_up