# Swap 2 variables without using temporary variable!

Perhaps the oldest technique most of programmers use, whether beginners or professional coders, to swap 2 variables a and b, is to declare a new temporary variable c, copy a to c then assign b to a and finally assign c to b. The following code should look familiar:

```        Dim a As Integer = 10
Dim b As Integer = 20
Dim c As Integer = a
a = b
b = c
```

This technique is really simple and easy to understand and perhaps this is the main reason of its widespread use. However, there is a minor problem using this technique, which is the allocation of a new variable(c) which incurs more memory usage. Although its just 1 more variable overhead, a total of 4 bytes integer it still represents a major drawback for memory-critical applications or on machines where memory space is too low or limited(such as mobile devices). The first new technique is also simple and has the advantage of not allocating space for a new temporary variable. This method uses addition and subtraction in a clever way in order to keep track of the a and b:

```        Dim a As Integer = 10
Dim b As Integer = 20
a = a + b
b = a - b
a = a - b
```

Lets analyze this code line by line:

1. a=10
2. b=20
3. a= 10 + 20 = 30
4. b= 30 – 20 = 10
5. a= 30 – 10 = 20
6. Final result: a=20 and b=10

This is really a very nice and smart way of swapping. You can encapsulate it in a function that takes two arguments by reference so that you don’t have to remember this arithmetic steps each time but I will leave this as an exercise to the reader:). Now let’s take a look at the next method which involves multiplication and division instead of addition and subtraction:

```        Dim a As Integer = 10
Dim b As Integer = 20
a = a * b
b = a / b
a = a / b
```

Again,Lets analyze this code line by line:

1. a=10
2. b=20
3. a= 10 * 20 = 200
4. b= 200 / 20 = 10
5. a= 200 / 10 = 20
6. Final result: a=20 and b=10

I have created a console application and added all the 3 methods then I surrounded each method with a very long loop in order to simulate a compute intensive operation in order to measure the speed of each one using a Stopwatch. The complete code looks like this:

```    Sub Main()
Dim a As Integer = 10
Dim b As Integer = 20
Console.WriteLine("Original values")
Console.WriteLine("a: {0}, b: {1}", a, b)
Dim s As New Stopwatch
s.Start()
For i As Integer = 0 To 10000002
a = a + b
b = a - b
a = a - b
Next
s.Stop()
Console.WriteLine("a: {0}, b: {1}, Time: {2}", a, b, s.ElapsedMilliseconds)

a = 10
b = 20

s.Restart()
For i As Integer = 0 To 10000002
Dim c As Integer = a
a = b
b = c
Next

s.Stop()
Console.WriteLine("Swap with temporary variable")
Console.WriteLine("a: {0}, b: {1}, Time: {2}", a, b, s.ElapsedMilliseconds)

a = 10
b = 20

s.Restart()
For i As Integer = 0 To 10000002
a = a * b
b = a / b
a = a / b
Next
s.Stop()
Console.WriteLine("Swap using multiplication division")
Console.WriteLine("a: {0}, b: {1}, Time: {2}", a, b, s.ElapsedMilliseconds)

End Sub
```

Running this application produced interesting measurements, 1 in particular that I did not expect:

As you can see, the method using a temporary variable outperformed the other two. I was expecting that the multiplication and division method to be the worst because of the division overhead but I thought that the addition and subtraction method will compete, but it looks like using the temporary variable is about twice faster. This can be explained because memory allocation in the .net framework is incredibly fast and the heap manager does some magic in allocation. In fact, memory allocation in .net is as fast as allocating memory in C using the malloc function and it’s even faster sometimes.

Final thoughts:
If you are using the temporary variable method for swapping variables, keep using it:) it’s the right thing to do unless you are a memory geek or developing applications for mobile devices then perhaps you should switch to the addition/subtraction method.

### One Response to Swap 2 variables without using temporary variable!

1. Ali Tarhini says:

One of the powerful features of C++ is pointers. To implement swap using pointers the following is done:

void swap(int* p, int* q) {
int temp;
temp = *p;
*p = *q;
*q = temp;
}

// example call:
swap(&intOne, &intTwo);