Home

Learning Hub

Articles

How to Write a C Program to Swap Two Numbers Without Using Third Variable

Have you ever had to swap two numbers in C without using any extra variable? Well, it’s the common case when you work under low memory or even when you are just making an attempt to code efficiently.

C Program to swap two numbers without using third variable is not just another coding trick but a good way to equip us with the skills to work on our code efficiently and resourcefully.

So, why is it even important? Because we need to think outside the box.

When not using an extra variable, one is pushed towards creative solutions. It is a trick in itself, which is often asked in coding interviews.

Also Read: C programming Tutorial

Method 1: Swapping Two Numbers Using Addition and Subtraction

This is one of the simplest ways of swapping two numbers without a third variable. It uses basic arithmetic operations of addition and subtraction.

Here’s how it works.

Step-by-Step Explanation:

1. We start with two variables, say a and b.
2. First, we add b to a. This gives us a sum that contains the values of both a and b.
3. Next, we subtract b (which is still the original value of b) from the sum stored in a. This subtraction leaves us with the original value of a stored in b.
4. Finally, we subtract the new value of b from the sum stored in a. This gives us the original value of b in a.

Example:

Let’s swap the numbers 12 and 8 using this method.

Output:

The beauty of this method is in its simplicity.

It’s just three lines of code after the input. There’s no need for a temporary variable, and we get the job done efficiently.

Key Points to Remember:

• Avoid overflow: Be cautious with very large numbers, as adding them might cause an overflow.
• Perfect for integers: This method works best with integers. Avoid using it with floating-point numbers, as precision issues can arise.

Method 2: Swapping Two Numbers Using Multiplication and Division

If we would like to look into another way of swapping without using a third variable, multiplication and division can help us. It will apply the very idea of addition and subtraction but use multiplication and division instead.

Step-by-Step Explanation:

1. Start with two variables, a and b.
2. Multiply a by b and store the result in a. Now, a contains the product of the original values of a and b.
3. Divide the new a (which is the product) by b to retrieve the original value of a and store it in b.
4. Finally, divide the new a (still the product) by the new b to retrieve the original value of b and store it in a.

Example:

Let’s swap the numbers 7 and 3 using multiplication and division.

Output:

Key Points to Remember:

• Division by zero: The method defined above does not work if one of the numbers is zero. Before performing a division, always check that neither number is equal to zero.
• Risk of overflow: As in addition and subtraction, we also handle big numbers with caution here since the product may turn out greater than the maximum value that can be stored in an integer.

Are you looking for a more advanced method to swap two numbers without a third variable? Let’s dive into the Bitwise XOR technique.

Why XOR?

The XOR operation is a bitwise function that compares each bit of two numbers.

If the bits are different, XOR gives a 1; if they’re the same, it gives a 0. This characteristic allows us to swap values in a clever way without needing extra memory space.

Step-by-Step Explanation:

1. Start with two variables, a and b.
2. Perform a = a ^ b. Now, a holds the XOR of the original a and b.
3. Perform b = a ^ b. This operation gives the original value of a, and stores it in b.
4. Perform a = a ^ b. This step retrieves the original value of b, and stores it in a.

Example:

Let’s swap the numbers 15 and 9 using the XOR operator.

Key Points to Remember:

• This method is efficient and avoids the pitfalls of arithmetic overflow
• This method works best with integer data types
• Using it with floating-point numbers or pointers can lead to unexpected results.

Important Considerations When Swapping Numbers Without a Temporary Variable

When we swap numbers without a third variable, we must be careful about a few things. These methods are not one-size-fits-all. Let’s break down what to watch out for.

Be Mindful of Data Types

Each method works differently with various data types.

• Addition/Subtraction and Multiplication/Division: These methods are great with integers but can cause trouble with floats or doubles due to precision loss.
• Bitwise XOR: It’s perfect for integers but not suitable for floating-point numbers or pointers. Stick to what’s safe.

Handle Zeroes with Care

If either of the numbers is zero, the multiplication/division method can lead to a division by zero error, crashing your program.

It’s crucial to check that neither number is zero before using this approach.

Watch Out for Overflow

When dealing with very large numbers, an addition/subtraction or multiplication/division method may be overrun.

This occurs when the result is greater than the maximum value that can be stored in an integer.

To avoid this, try using larger capacity data types like long or long long; even so, it’s better to use it carefully.

Stick to Integers for XOR

The XOR method shines with integers, thanks to its bitwise nature. But it’s not designed for floats, doubles, or pointers.

If you try it with these types, you’ll likely run into problems.

Consider Readability and Maintenance

While these methods are clever, they can also be confusing to someone reading your code later.

However, sometimes it is worthwhile using a temporary variable for clarity when working in a team or writing code which others will maintain.

Common Mistakes to Avoid When Implementing These Methods

Swapping two numbers without a third variable sounds simple, but there are common mistakes we need to avoid.

Ignoring Data Type Limits

Forgetting about the limits of the data types can lead to unexpected results.

Always be aware of the maximum and minimum values that your data type can handle.

Neglecting Zero Checks

Using the multiplication/division method without checking for zero is a rookie mistake.

Always ensure that neither a nor b is zero before proceeding with the swap.

Misusing XOR with Non-Integer Types

Trying to use the XOR method with non-integer types like floats, doubles, or pointers can mess up your program.

Stick to integers, where XOR works flawlessly.

Overlooking Overflow Risks

When working with large numbers, always be cautious of overflow.

It’s easy to miss, but it can lead to incorrect results or crashes.

Sacrificing Code Clarity

While it’s tempting to show off with these techniques, remember that readability matters.

If your code becomes hard to understand, it might be better to use a temporary variable.

Conclusion

Learning how to write a C Program to swap two numbers without using third variable requires a lot more than traditional programming knowledge.

It is a skill that can improve our proficiency in writing optimal code and optimising our programs.

Each of the ways – by addition and subtraction, multiplication and division, or the bitwise XOR method – has its own benefits.

Hereby, recognizing the advantages and drawbacks of these techniques, we may determine which of them is the most suitable one for a particular task.