# 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 sum in one of the two given numbers. The numbers can then be swapped using the sum and subtraction from 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.*;`   `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 swaping:"` `                           ``+ ``" x = "` `+ x + ``", y = "` `+ y);` `    ``}` `}`   `// This code is contributed by Sam007`

## Python 3

 `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

 ``

Output :

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

```

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 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 50` `    ``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` `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 swaping:"` `                           ``+ ``" x = "` `+ x + ``", y = "` `+ y);` `    ``}` `}`   `// This code is contributed by ajit`

## 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 swaping:"` `                          ``+ ``" x = "` `+ x + ``", y = "` `+ y);` `    ``}` `}`   `// This code is contributed by ajit.`

## PHP

 ``

Output :

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

```

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 which 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.*;`   `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 Sam007.`

## Python3

 `# Python 3 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

 ``

Output :

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

```

Problems with 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 arithmetic overflow. If x and y are too large, addition and multiplication may go out of integer range.
3) When we use pointers to variable and make a function swap, all of the above methods fail when both pointers point to the same variable. Let’s take a look 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 = "``<

## 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 Rajput-Ji`

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

## PHP

 ``

Output :

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

```

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 the 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

 `

Output :

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

```

Method 3 (A mixture of bitwise operators and arithmetic operators)
The idea is the same as discussed in Method 1 but using Bitwise addition and subtraction for swapping.
Below is the implementation of the above approach.

## C++

 `//C++ program to swap two numbers.` `//Including header file.` `#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;`   `    ``//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 yashbeersingh42`

Output :

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

```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

70

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.