 GeeksforGeeks App
Open App Browser
Continue

# How to swap two numbers without using a temporary variable?

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

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.

## C++

 `// C++ Program to swap two numbers  without``// using temporary variable``#include ``using` `namespace` `std;` `int` `main()``{``    ``int` `x = 10, y = 5;` `    ``// Code to swap 'x' and 'y'``    ``x = x + y; ``// x now becomes 15``    ``y = x - y; ``// y becomes 10``    ``x = x - y; ``// x becomes 5``    ``cout << ``"After Swapping: x ="` `<< x << ``", y="` `<< y;``}` `// This code is contributed by mohit kumar.`

## C

 `#include ``int` `main()``{``    ``int` `x = 10, y = 5;` `    ``// Code to swap 'x' and 'y'``    ``x = x + y; ``// x now becomes 15``    ``y = x - y; ``// y becomes 10``    ``x = x - y; ``// x becomes 5` `    ``printf``(``"After Swapping: x = %d, y = %d"``, x, y);` `    ``return` `0;``}`

## Java

 `// Java Program to swap two numbers  without``// using temporary variable``import` `java.io.*;` `class` `Geeks {` `    ``public` `static` `void` `main(String a[])``    ``{``        ``int` `x = ``10``;``        ``int` `y = ``5``;``        ``x = x + y;``        ``y = x - y;``        ``x = x - y;``        ``System.out.println(``"After swapping:"``                           ``+ ``" x = "` `+ x + ``", y = "` `+ y);``    ``}``}` `// This code is contributed by Mayank Tyagi`

## Python3

 `x ``=` `10``y ``=` `5` `# Code to swap 'x' and 'y'` `# x now becomes 15``x ``=` `x ``+` `y` `# y becomes 10``y ``=` `x ``-` `y` `# x becomes 5``x ``=` `x ``-` `y``print``(``"After Swapping: x ="``, x, ``" y ="``, y)` `# This code is contributed``# by Sumit Sudhakar`

## C#

 `// Program to swap two numbers  without``// using temporary variable``using` `System;` `class` `GFG {``    ``public` `static` `void` `Main()``    ``{``        ``int` `x = 10;``        ``int` `y = 5;` `        ``x = x + y;``        ``y = x - y;``        ``x = x - y;``        ``Console.WriteLine(``"After swapping: x = "` `+ x``                          ``+ ``", y = "` `+ y);``    ``}``}` `// This code is contributed by Sam007`

## PHP

 ``

## Javascript

 ``

Output

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

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

Multiplication and division can also be used for swapping.

## C++

 `// C++ Program to swap two numbers without using temporary``// variable``#include ``using` `namespace` `std;` `int` `main()``{ ``// NOTE - for this code to work in a generalised sense, y``  ``// !- 0 to prevent zero division``    ``int` `x = 10, y = 5;` `    ``// Code to swap 'x' and 'y'``    ``x = x * y; ``// x now becomes 50``    ``y = x / y; ``// y becomes 10``    ``x = x / y; ``// x becomes 5``    ``cout << ``"After Swapping: x ="` `<< x << ``", y="` `<< y;``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// C Program to swap two numbers without using temporary``// variable``#include ``int` `main()``{``    ``int` `x = 10, y = 5;` `    ``// Code to swap 'x' and 'y'``    ``x = x * y; ``// x now becomes 50``    ``y = x / y; ``// y becomes 10``    ``x = x / y; ``// x becomes 5` `    ``printf``(``"After Swapping: x = %d, y = %d"``, x, y);` `    ``return` `0;``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## Java

 `// Java Program to swap two numbers without using temporary``// variable``import` `java.io.*;` `class` `GFG {``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `x = ``10``;``        ``int` `y = ``5``;` `        ``// Code to swap 'x' and 'y'``        ``x = x * y; ``// x now becomes 50``        ``y = x / y; ``// y becomes 10``        ``x = x / y; ``// x becomes 5` `        ``System.out.println(``"After swapping:"``                           ``+ ``" x = "` `+ x + ``", y = "` `+ y);``    ``}``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## Python3

 `# Python3 program to``# swap two numbers``# without using``# temporary variable``x ``=` `10``y ``=` `5` `# code to swap``# 'x' and 'y'` `# x now becomes 50``x ``=` `x ``*` `y` `# y becomes 10``y ``=` `x ``/``/` `y;` `# x becomes 5``x ``=` `x ``/``/` `y;` `print``(``"After Swapping: x ="``,``              ``x, ``" y ="``, y);` `# This code is contributed``# by @ajit`

## C#

 `// C# Program to swap two``// numbers without using``// temporary variable``using` `System;` `class` `GFG {``    ``static` `public` `void` `Main()``    ``{``        ``int` `x = 10;``        ``int` `y = 5;` `        ``// Code to swap 'x' and 'y'``        ``x = x * y; ``// x now becomes 50``        ``y = x / y; ``// y becomes 10``        ``x = x / y; ``// x becomes 5` `        ``Console.WriteLine(``"After swapping:"``                          ``+ ``" x = "` `+ x + ``", y = "` `+ y);``    ``}``}` `// This code is contributed by ajit.`

## PHP

 ``

## Javascript

 ``

Output

`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).

## C++

 `// C++ code to swap using XOR``#include ` `using` `namespace` `std;` `int` `main()``{``    ``int` `x = 10, y = 5;``    ``// Code to swap 'x' (1010) and 'y' (0101)``    ``x = x ^ y; ``// x now becomes 15 (1111)``    ``y = x ^ y; ``// y becomes 10 (1010)``    ``x = x ^ y; ``// x becomes 5 (0101)``    ``cout << ``"After Swapping: x ="` `<< x << ``", y="` `<< y;``    ``return` `0;``}` `// This code is contributed by mohit kumar.`

## C

 `// C code to swap using XOR``#include ``int` `main()``{``    ``int` `x = 10, y = 5;` `    ``// Code to swap 'x' (1010) and 'y' (0101)``    ``x = x ^ y; ``// x now becomes 15 (1111)``    ``y = x ^ y; ``// y becomes 10 (1010)``    ``x = x ^ y; ``// x becomes 5 (0101)` `    ``printf``(``"After Swapping: x = %d, y = %d"``, x, y);` `    ``return` `0;``}`

## Java

 `// Java code to swap using XOR``import` `java.io.*;` `public` `class` `GFG {` `    ``public` `static` `void` `main(String a[])``    ``{``        ``int` `x = ``10``;``        ``int` `y = ``5``;` `        ``// Code to swap 'x' (1010) and 'y' (0101)``        ``x = x ^ y; ``// x now becomes 15 (1111)``        ``y = x ^ y; ``// y becomes 10 (1010)``        ``x = x ^ y; ``// x becomes 5 (0101)` `        ``System.out.println(``"After swap: x = "``                           ``+ x + ``", y = "` `+ y);``    ``}``}` `// This code is contributed by Mayank Tyagi`

## Python3

 `# Python3 code to swap using XOR` `x ``=` `10``y ``=` `5` `# Code to swap 'x' and 'y'``x ``=` `x ^ y; ``# x now becomes 15 (1111)``y ``=` `x ^ y; ``# y becomes 10 (1010)``x ``=` `x ^ y; ``# x becomes 5 (0101)` `print` `(``"After Swapping: x = "``, x, ``" y ="``, y)` `# This code is contributed by``# Sumit Sudhakar`

## C#

 `// C# program to swap using XOR``using` `System;` `class` `GFG {``    ``public` `static` `void` `Main()``    ``{``        ``int` `x = 10;``        ``int` `y = 5;` `        ``// Code to swap 'x' (1010)``        ``// and 'y' (0101)` `        ``// x now becomes 15 (1111)``        ``x = x ^ y;` `        ``// y becomes 10 (1010)``        ``y = x ^ y;` `        ``// x becomes 5 (0101)``        ``x = x ^ y;` `        ``Console.WriteLine(``"After swap: x = "` `+ x + ``", y = "` `+ y);``    ``}``}` `// This code is contributed by ajit`

## PHP

 ``

## Javascript

 ``

Output

`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

Let us see the following program.

## C++

 `#include ``using` `namespace` `std;``void` `swap(``int``* xp, ``int``* yp)``{``    ``*xp = *xp ^ *yp;``    ``*yp = *xp ^ *yp;``    ``*xp = *xp ^ *yp;``}` `// Driver code``int` `main()``{``    ``int` `x = 10;``    ``swap(&x, &x);``    ``cout << ``"After swap(&x, &x): x = "` `<< x;``    ``return` `0;``}` `// This code is contributed by rathbhupendra`

## C

 `#include ``void` `swap(``int``* xp, ``int``* yp)``{``    ``*xp = *xp ^ *yp;``    ``*yp = *xp ^ *yp;``    ``*xp = *xp ^ *yp;``}` `int` `main()``{``    ``int` `x = 10;``    ``swap(&x, &x);``    ``printf``(``"After swap(&x, &x): x = %d"``, x);``    ``return` `0;``}`

## Java

 `class` `GFG {``    ``static` `void` `swap(``int``[] xp, ``int``[] yp)``    ``{``        ``xp[``0``] = xp[``0``] ^ yp[``0``];``        ``yp[``0``] = xp[``0``] ^ yp[``0``];``        ``xp[``0``] = xp[``0``] ^ yp[``0``];``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[] x = { ``10` `};``        ``swap(x, x);``        ``System.out.println(``"After swap(&x, &x): x = "` `+ x[``0``]);``    ``}``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## Python3

 `def` `swap(xp, yp):` `    ``xp[``0``] ``=` `xp[``0``] ^ yp[``0``]``    ``yp[``0``] ``=` `xp[``0``] ^ yp[``0``]``    ``xp[``0``] ``=` `xp[``0``] ^ yp[``0``]`  `# Driver code``x ``=` `[``10``]``swap(x, x)``print``(``"After swap(&x, &x): x = "``, x[``0``])` `# This code is contributed by SHUBHAMSINGH10`

## C#

 `// C# program to implement``// the above approach``using` `System;``class` `GFG {` `    ``static` `void` `swap(``int``[] xp, ``int``[] yp)``    ``{``        ``xp = xp ^ yp;``        ``yp = xp ^ yp;``        ``xp = xp ^ yp;``    ``}` `    ``// Driver code``    ``static` `void` `Main()``    ``{``        ``int``[] x = { 10 };``        ``swap(x, x);``        ``Console.WriteLine(``"After swap(&x,"``                          ``+ ``"&x): x = "` `+ x);``    ``}``}` `// This code is contributed by divyeshrabadiya07`

## PHP

 ``

## Javascript

 ``

Output

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

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

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.

## C++

 `#include ``using` `namespace` `std;``void` `swap(``int``* xp, ``int``* yp)``{` `    ``// Check if the two addresses are same``    ``if` `(xp == yp)``        ``return``;``    ``*xp = *xp + *yp;``    ``*yp = *xp - *yp;``    ``*xp = *xp - *yp;``}` `// Driver Code``int` `main()``{``    ``int` `x = 10;``    ``swap(&x, &x);``    ``cout << ``"After swap(&x, &x): x = "` `<< x;``    ``return` `0;``}` `// This code is contributed by rathbhupendra`

## C

 `#include ``void` `swap(``int``* xp, ``int``* yp)``{``    ``if` `(xp == yp) ``// Check if the two addresses are same``        ``return``;``    ``*xp = *xp + *yp;``    ``*yp = *xp - *yp;``    ``*xp = *xp - *yp;``}``int` `main()``{``    ``int` `x = 10;``    ``swap(&x, &x);``    ``printf``(``"After swap(&x, &x): x = %d"``, x);``    ``return` `0;``}`

## Java

 `// Java program of above approach``class` `GFG {` `    ``static` `void` `swap(``int` `xp, ``int` `yp)``    ``{``        ``if` `(xp == yp) ``// Check if the two addresses are same``            ``return``;``        ``xp = xp + yp;``        ``yp = xp - yp;``        ``xp = xp - yp;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `x = ``10``;``        ``swap(x, x);``        ``System.out.println(``"After swap(&x, &x): x = "` `+ x);``    ``}``}` `// This code is Contributed by Code_Mech.`

## Python3

 `# Python3 program of above approach``def` `swap(xp, yp):` `    ``# Check if the two addresses are same``    ``if` `(xp[``0``] ``=``=` `yp[``0``]):``        ``return``    ``xp[``0``] ``=` `xp[``0``] ``+` `yp[``0``]``    ``yp[``0``] ``=` `xp[``0``] ``-` `yp[``0``]``    ``xp[``0``] ``=` `xp[``0``] ``-` `yp[``0``]`  `# Driver Code``x ``=` `[``10``]``swap(x, x)``print``(``"After swap(&x, &x): x = "``, x[``0``])` `# This code is contributed by SHUBHAMSINGH10`

## C#

 `// C# program of above approach``using` `System;``class` `GFG {` `    ``static` `void` `swap(``int` `xp, ``int` `yp)``    ``{``        ``if` `(xp == yp) ``// Check if the two addresses are same``            ``return``;``        ``xp = xp + yp;``        ``yp = xp - yp;``        ``xp = xp - yp;``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int` `x = 10;``        ``swap(x, x);``        ``Console.WriteLine(``"After swap(&x, &x): x = "` `+ x);``    ``}``}` `// This code is Contributed by Code_Mech.`

## PHP

 `

## Javascript

 ``

Output

`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.

Below is the implementation of the above approach.

## C++

 `// C++ program to swap two numbers``#include ``using` `namespace` `std;` `// Function to swap the numbers.``void` `swap(``int``& a, ``int``& b)``{``    ``// same as a = a + b``    ``a = (a & b) + (a | b);``    ``// same as b = a - b``    ``b = a + (~b) + 1;``    ``// same as a = a - b``    ``a = a + (~b) + 1;``}` `// Driver Code``int` `main()``{``    ``int` `a = 5, b = 10;``    ``// Function Call``    ``swap(a, b);``    ``cout << ``"After swapping: a = "` `<< a << ``", b = "` `<< b;``    ``return` `0;``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// C program to swap two numbers``#include ` `// Function to swap the numbers.``void` `swap(``int` `a, ``int` `b)``{``    ``// same as a = a + b``    ``a = (a & b) + (a | b);``    ``// same as b = a - b``    ``b = a + (~b) + 1;``    ``// same as a = a - b``    ``a = a + (~b) + 1;``      ``printf``(``"After swapping: a = %d , b = %d "``,a,b);``}` `// Driver Code``int` `main()``{``    ``int` `a = 5, b = 10;``    ``// Function Call``    ``swap(a, b);``    ``return` `0;``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## Java

 `// Java program to swap two numbers``import` `java.io.*;` `class` `GFG {``    ``public` `static` `void` `swap(``int` `a, ``int` `b)``    ``{``        ``// same as a = a + b``        ``a = (a & b) + (a | b);``        ``// same as b = a - b``        ``b = a + (~b) + ``1``;``        ``// same as a = a - b``        ``a = a + (~b) + ``1``;``        ``System.out.print(``"After swapping: a = "` `+ a + ``", b = "` `+ b);``    ``}``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `a = ``5``, b = ``10``;``        ``// Function Call``        ``swap(a, b);``    ``}``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## Python3

 `# Python3 program to swap two numbers` `# Function to swap the numbers`  `def` `swap(a, b):` `    ``# Same as a = a + b``    ``a ``=` `(a & b) ``+` `(a | b)` `    ``# Same as b = a - b``    ``b ``=` `a ``+` `(~b) ``+` `1` `    ``# Same as a = a - b``    ``a ``=` `a ``+` `(~b) ``+` `1` `    ``print``(``"After Swapping: a = "``, a, ``", b = "``, b)`  `# Driver code``a ``=` `5``b ``=` `10` `# Function call``swap(a, b)` `# This code is contributed by bunnyram19`

## C#

 `// C# program to swap two numbers``using` `System;``class` `GFG {` `    ``static` `void` `swap(``int` `a, ``int` `b)``    ``{``        ``// same as a = a + b``        ``a = (a & b) + (a | b);` `        ``// same as b = a - b``        ``b = a + (~b) + 1;` `        ``// same as a = a - b``        ``a = a + (~b) + 1;` `        ``Console.Write(``"After swapping: a = "` `+ a``                      ``+ ``", b = "` `+ b);``    ``}` `    ``static` `void` `Main()``    ``{``        ``int` `a = 5, b = 10;` `        ``// Function Call``        ``swap(a, b);``    ``}``}` `// This code is contributed by divyesh072019`

## Javascript

 ``

## PHP

 `"``);``// same as a = a + b``    ``\$a` `= (``\$a` `& ``\$b``) + (``\$a` `| ``\$b``);`` ` `    ``// same as b = a - b``    ``\$b` `= ``\$a` `+ (~``\$b``) + 1;`` ` `    ``// same as a = a - b``    ``\$a` `= ``\$a` `+ (~``\$b``) + 1;` `echo``(``"After swap(a and b) "` `. ``\$a``. ``"and"``. ``\$b``);``return` `0;` `?>`

Output

`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)

## C++

 `#include ``using` `namespace` `std;`` ` `int` `main(){``    ``int` `x = 10, y = 5;``    ``x = (x * y) / (y = x);``    ``cout << x << ``" "` `<< y;``    ``return` `0;``}` `// This code is contributed by isha307`

## C

 `#include ` `int` `main() {``    ``int` `x = 10, y = 5;``    ``x = (x * y) / (y = x);``    ``printf``(``"After Swapping: x = %d, y = %d"``, x, y);``    ``return` `0;``}` `// This code is contributed by isha307`

## Java

 `/*package whatever //do not write package name here */``import` `java.io.*;` `class` `GFG {``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `x = ``10``;``        ``int` `y = ``5``;``        ``x = (x * y) / (y = x);``        ``System.out.println(``"After swapping:"``                           ``+ ``" x = "` `+ x + ``", y = "` `+ y);``    ``}``}` `// This code is contributed by isha307`

## Python3

 `# Python3 program to swap two numbers` `# Function to swap the numbers``def` `swap(x, y):``  ``x , y ``=` `y, x``  ``print``(``"After Swapping: x = "``, x, ``", y = "``, y)``  ` `# Driver code``x ``=` `10``y ``=` `5`` ` `# Function call``swap(x, y)`` ` `# This code is contributed by kothavvsaakash`

## C#

 `// C# program to swap two numbers` `using` `System;` `public` `class` `GFG``{``    ``static` `public` `void` `Main ()``    ``{``        ``int` `x = 10;``        ``int` `y = 5;``        ``x = (x * y) / (y = x);``        ``Console.Write(``"After swapping:"`  `+ ``" x = "` `+ x + ``", y = "` `+ y);``    ``}``}` `// This code is contributed by kothavvsaakash`

## Javascript

 ``

Output

`5 10`

Time Complexity: O(1)

Auxiliary Space: O(1)