Swapping Of Two Numbers In C | 7 Methods Explained (+Code Examples)

In this article, we will discuss the ways to carry out the swapping of two numbers in C programming language with the help of code examples and explanations. Swapping two numbers is a common operation wherein we exchange the values of two variables.

Say you have two variables, var1, and var2; swapping entails assigning the value of the 1st variable to the 2nd variable, and vice versa. Understanding how to perform such manipulations is important for developing the right programming skills. There are five common ways of swapping two numbers in C programs, including:

1. Temporary Integer Variable (3rd Variable)
2. Arithmetic Operations
3. Bitwise XOR Operator
4. Custom Swap Function
5. Pointer Variables
6. The memcpy() Function (<string.h> Library)
7. One‑Line Expression

We will discuss all these methods in proper detail with examples in the section above.

Swapping Two Numbers in C With Temporary Variable

This is the most straightforward and commonly used approach to swap two numbers in the C language. The temporary variable method is also referred to as swapping two numbers with a third variable. Here are the general steps to write and run a C program to swap two numbers using this approach:

• Declare variables: We declare three variables, i.e., the 1st variable and the 2nd variable, to hold values for variables to be swapped and the 3rd variable to act as the temporary variable. 
• User Input: If you are not taking given values, then prompt the user to provide input for the 1st and 2nd variables and store them accordingly. 
• Initialize Temporary & Swap: The next step is to assign the value of 1st variable to the temporary variable.
  • Then, assign the value of the 2nd variable to the 1st variable. Here, you have effectively stored the value of the 2nd variable in the 1st.
  • Next, assign the value stored in the temp variable (which originally had the value of 1st variable) to 2nd variable.

In this way, you can easily swap two numbers in C programming. Below is a simple C program example illustrating this.

Code Example:

            #include 

int main() {

//Declaring two separate variables with given values
int num1 = 10;
int num2 = 20;

printf("Before swapping:\n");
printf("num1 = %d ", num1);
printf("num2 = %d", num2);

int temp; // Declaring the third variable to facilitate swapping

// Step 1: Store the value of num1 in the temporary variable
temp = num1;
// Step 2: Assign the value of num2 to num1
num1 = num2;
// Step 3: Assign the value in the temporary variable to num2
num2 = temp;

printf("\nAfter swapping:\n");
printf("num1 = %d ", num1);
printf("num2 = %d", num2);

return 0;
}
          

I2luY2x1ZGUgPHN0ZGlvLmg+CgppbnQgbWFpbigpIHsKCi8vRGVjbGFyaW5nIHR3byBzZXBhcmF0ZSB2YXJpYWJsZXMgd2l0aCBnaXZlbiB2YWx1ZXMKaW50IG51bTEgPSAxMDsKaW50IG51bTIgPSAyMDsKCnByaW50ZigiQmVmb3JlIHN3YXBwaW5nOlxuIik7CnByaW50ZigibnVtMSA9ICVkICIsIG51bTEpOwpwcmludGYoIm51bTIgPSAlZCIsIG51bTIpOwoKaW50IHRlbXA7IC8vIERlY2xhcmluZyB0aGUgdGhpcmQgdmFyaWFibGUgdG8gZmFjaWxpdGF0ZSBzd2FwcGluZwoKLy8gU3RlcCAxOiBTdG9yZSB0aGUgdmFsdWUgb2YgbnVtMSBpbiB0aGUgdGVtcG9yYXJ5IHZhcmlhYmxlCnRlbXAgPSBudW0xOwovLyBTdGVwIDI6IEFzc2lnbiB0aGUgdmFsdWUgb2YgbnVtMiB0byBudW0xCm51bTEgPSBudW0yOwovLyBTdGVwIDM6IEFzc2lnbiB0aGUgdmFsdWUgaW4gdGhlIHRlbXBvcmFyeSB2YXJpYWJsZSB0byBudW0yCm51bTIgPSB0ZW1wOwoKcHJpbnRmKCJcbkFmdGVyIHN3YXBwaW5nOlxuIik7CnByaW50ZigibnVtMSA9ICVkICIsIG51bTEpOwpwcmludGYoIm51bTIgPSAlZCIsIG51bTIpOwoKcmV0dXJuIDA7Cn0=

Output:

Before swapping:
num1 = 10 num2 = 20
After swapping:
num1 = 20 num2 = 10

Explanation:

In the simple C code example, we first include the <stdio.h> header file for input/ output operations and then initiate the main() function, which is the program's entry point for execution.

1. Inside the main() function, we declare two integer variables, num1 and num2, and assign them values 10 and 20, respectively. 
2. Then, we use a set of printf() statements to display these values to the console with a string message.
3. In the string message, the %d format specifier indicates integer values, and the newline escape sequence shifts the cursor to the next line.
4. As mentioned in the code comment, we then declare an integer data type variable temp to act as the temporary variable.
5. Next, we assign the value of num1 to the temp variable, followed by assigning the value of the num2 variable to num1. At this point, num1 has the value of the 2nd variable.
6. After that, we assign the value stored in the temp variable to num2, effectively swapping the values of num1 with num2.
7. Lastly, we again use a set of printf() statements to display the values of the number after swapping.
8. Finally, the main() function terminates with a return 0 statement indicating successful execution without any error.

Time Complexity: O(1) — The program runs in constant time regardless of input. The entire program involves simple assignments and print statements, each taking constant time.
Space Complexity: O(1) — The program uses a constant amount of memory for variables regardless of input.

Swapping Program in C Using Arithmetic Operators (Without Third Variable)

Arithmetic operators help us perform arithmetic operations on two or more operands. They consist of addition (+), subtraction (-), multiplication (*), modulus (%), etc. operators. The working mechanism of the C program to swap two numbers using arithmetic operators is given below.

This approach involves swapping two variables in C without using a third/ temp variable. Instead, we use the subtraction and addition arithmetic operators to swap the values of two numbers.

• We declare two variables, say, num1 and num2, to store the initial values that will be swapped.
• Then, use the addition operator to add num1 and num2 and subsequently store the sum in num1.
• Next, subtract num2 from the updated num1 and store the result in num2.
• And finally, subtract the updated num2 from the updated num1 and store the result in num1. This effectively swaps the values of the two numbers.

Below is a C program example that illustrates this approach to swapping of two numbers in C language, where the values are taken from the user.

Code Example:

            #include 

int main() {

// Declare variables to hold the two numbers
int num1, num2;

//Prompting user to provide input for the two variables
printf("Enter the first number: ");
scanf("%d", &num1);
printf("Enter the second number: ");
scanf("%d", &num2);

printf("Before swapping: num1 = %d, num2 = %d\n", num1, num2); 

// Swap the values of the two numbers using arithmetic operators
num1 = num1 + num2;
num2 = num1 - num2;
num1 = num1 - num2;

// Display the values of numbers after swapping
printf("After swapping: num1 = %d, num2 = %d\n", num1, num2);

return 0;
}
          

I2luY2x1ZGUgPHN0ZGlvLmg+CgppbnQgbWFpbigpIHsKCi8vIERlY2xhcmUgdmFyaWFibGVzIHRvIGhvbGQgdGhlIHR3byBudW1iZXJzCmludCBudW0xLCBudW0yOwoKLy9Qcm9tcHRpbmcgdXNlciB0byBwcm92aWRlIGlucHV0IGZvciB0aGUgdHdvIHZhcmlhYmxlcwpwcmludGYoIkVudGVyIHRoZSBmaXJzdCBudW1iZXI6ICIpOwpzY2FuZigiJWQiLCAmbnVtMSk7CnByaW50ZigiRW50ZXIgdGhlIHNlY29uZCBudW1iZXI6ICIpOwpzY2FuZigiJWQiLCAmbnVtMik7CgpwcmludGYoIkJlZm9yZSBzd2FwcGluZzogbnVtMSA9ICVkLCBudW0yID0gJWRcbiIsIG51bTEsIG51bTIpO8KgCgovLyBTd2FwIHRoZSB2YWx1ZXMgb2YgdGhlIHR3byBudW1iZXJzIHVzaW5nIGFyaXRobWV0aWMgb3BlcmF0b3JzCm51bTEgPSBudW0xICsgbnVtMjsKbnVtMiA9IG51bTEgLSBudW0yOwpudW0xID0gbnVtMSAtIG51bTI7CgovLyBEaXNwbGF5IHRoZSB2YWx1ZXMgb2YgbnVtYmVycyBhZnRlciBzd2FwcGluZwpwcmludGYoIkFmdGVyIHN3YXBwaW5nOiBudW0xID0gJWQsIG51bTIgPSAlZFxuIiwgbnVtMSwgbnVtMik7CgpyZXR1cm4gMDsKfQ==

Output:

Enter the first number: 23
Enter the second number: 44
Before swapping: num1 = 23, num2 = 44
After swapping: num1 = 44, num2 = 23

Explanation:

In this C code example-

1. We declare two integer variables, num1 and num2, inside the main() function, then use the printf() function to prompt the user to provide input for these variables.
2. Then, we use the scanf() function to read the user input and store them in respective variables using the address-of operator (&). 
3. Next, we perform a set of arithmetic operations on these values to swap the two. 
   • First, we add the values of num1 and num2 and assign the outcome to variable num1.
   • Then, we subtract the value of num2 from the updated value of num1 and assign the outcome to num2. At this point, num2 stores the original value of the num1 variable.
   • Again, we subtract num2 from num1, which will generate the initial value of num2, which we then store in the num1 variable.
4. After effectively swapping the two numbers, we use a printf() statement to display the updated values. We use the comma operator/separator in between the values.  

Time Complexity: O(1) — The program runs in constant time, with no loops or recursive calls, and all operations are simple arithmetic or input/output operations that take O(1) time.
Space Complexity: O(1) — The program uses a fixed amount of memory, for variables independent of input size.

Check out this amazing course to become the best version of the C programmer you can be.

Bitwise XOR Operator (^) to Swap Two Numbers in C

The bitwise operators work at the bit level of a value by comparing bits of two values and returning boolean values 0 and 1. The XOR operator compares the bits and returns 1 if either of the bits is 1 and 0 otherwise. We can use the bitwise XOR operator for swapping of two numbers in C programming, however it works only for unsigned integer values. Below is a C program sample that illustrates this approach.

Code Example:

            #include 

int main() {

int num1, num2;

printf("Enter the first number: ");
scanf("%d", &num1);
printf("Enter the second number: ");
scanf("%d", &num2);

printf("Before swapping:\n");
printf("num1 = %d ", num1);
printf("num2 = %d", num2);

// Swapping using XOR
num1 = num1 ^ num2;
num2 = num1 ^ num2;
num1 = num1 ^ num2;

printf("\nAfter swapping:\n");
printf("num1 = %d ", num1);
printf("num2 = %d", num2);

return 0; // End the program
}
          

I2luY2x1ZGUgPHN0ZGlvLmg+CgppbnQgbWFpbigpIHsKCmludCBudW0xLCBudW0yOwoKcHJpbnRmKCJFbnRlciB0aGUgZmlyc3QgbnVtYmVyOiAiKTsKc2NhbmYoIiVkIiwgJm51bTEpOwpwcmludGYoIkVudGVyIHRoZSBzZWNvbmQgbnVtYmVyOiAiKTsKc2NhbmYoIiVkIiwgJm51bTIpOwoKcHJpbnRmKCJCZWZvcmUgc3dhcHBpbmc6XG4iKTsKcHJpbnRmKCJudW0xID0gJWQgIiwgbnVtMSk7CnByaW50ZigibnVtMiA9ICVkIiwgbnVtMik7CgovLyBTd2FwcGluZyB1c2luZyBYT1IKbnVtMSA9IG51bTEgXiBudW0yOwpudW0yID0gbnVtMSBeIG51bTI7Cm51bTEgPSBudW0xIF4gbnVtMjsKCnByaW50ZigiXG5BZnRlciBzd2FwcGluZzpcbiIpOwpwcmludGYoIm51bTEgPSAlZCAiLCBudW0xKTsKcHJpbnRmKCJudW0yID0gJWQiLCBudW0yKTsKCnJldHVybiAwOyAvLyBFbmQgdGhlIHByb2dyYW0KfQ==

Output:

Enter the first number: 54
Enter the second number: 11
Before swapping:
num1 = 54 num2 = 11
After swapping:
num1 = 11 num2 = 54

Explanation:

In this C code sample-

1. We declare two integer variables, num1 and num2, inside the main() function and then store user-generated input in them.
2. Next, we use a set of printf() statements to display the values before swapping them with a string message.
3. Then, we use the bitwise XOR operator thrice to swap the two variable values. In that-
   • We first apply the XOR operation on num1 and num2 and store the outcome in the num1 variable.
   • Then, we again perform the XOR operation on num1 and num2 and store the outcome in the num2 variable. At this point, num2 will hold the initial value of the num1 variable.
   • Again, we perform the XOR operation and store the outcome in the num1 variable, effectively swapping the two values.
4. After swapping, we use a set of printf() statements to display the updated values.

Time Complexity: O(1) — The program runs in constant time, regardless of the values of num1 and num2.
Space Complexity: O(1) — The program uses a constant amount of memory, independent of input size.

Hone your coding skills with the 100-Day Coding Sprint at Unstop and claim bragging rights now!

Custom Swap Function for Swapping two Numbers in C

Pointer variables are special variables that point to other variables or store the memory address/ location of another variable instead of the data/ values. They can be used to indirectly access and manipulate the values stored in the variables, including swapping of two variables in C programming.

We use a third/ temporary variable to carry out swapping, just like in the temporary variable approach. The general process remains the same, with the primary difference being that we use the pointer to the variables instead of the variable names/ identifiers to swap. Also, it is best to enclose the process inside a function. Look at the sample C program below to better understand this concept.

Code Example:

            #include 

//Defining a swapping function that takes pointers to variables as parameters
void swap(int* a, int* b) {
int temp = *a;
*a = *b;
*b = temp;
}

int main() {

int num1 = 20;
int num2 = 30;
printf("Original numbers: num1 = %d, num2 = %d\n", num1, num2);

// Call the swap function to swap the numbers
swap(&num1, &num2);

// Print the swapped numbers
printf("Swapped numbers: num1 = %d, num2 = %d\n", num1, num2);

return 0;
}
          

I2luY2x1ZGUgPHN0ZGlvLmg+CgovL0RlZmluaW5nIGEgc3dhcHBpbmcgZnVuY3Rpb24gdGhhdCB0YWtlcyBwb2ludGVycyB0byB2YXJpYWJsZXMgYXMgcGFyYW1ldGVycwp2b2lkIHN3YXAoaW50KiBhLCBpbnQqIGIpIHsKaW50IHRlbXAgPSAqYTsKKmEgPSAqYjsKKmIgPSB0ZW1wOwp9CgppbnQgbWFpbigpIHsKCmludCBudW0xID0gMjA7CmludCBudW0yID0gMzA7CnByaW50ZigiT3JpZ2luYWwgbnVtYmVyczogbnVtMSA9ICVkLCBudW0yID0gJWRcbiIsIG51bTEsIG51bTIpOwoKLy8gQ2FsbCB0aGUgc3dhcCBmdW5jdGlvbiB0byBzd2FwIHRoZSBudW1iZXJzCnN3YXAoJm51bTEsICZudW0yKTsKCi8vIFByaW50IHRoZSBzd2FwcGVkIG51bWJlcnMKcHJpbnRmKCJTd2FwcGVkIG51bWJlcnM6IG51bTEgPSAlZCwgbnVtMiA9ICVkXG4iLCBudW0xLCBudW0yKTsKCnJldHVybiAwOwp9

Output:

Original numbers: num1 = 20, num2 = 30
Swapped numbers: num1 = 30, num2 = 20

Explanation:

 In this sample C code-

1. We define a function called swap() that takes two integer pointers (int* a and int* b) as parameters. Inside this function with pointers-
   • We declare an integer variable temp to store the temporary value during the swapping process.
   • Then, using the dereference operator (*), we assign the value stored in variable a to the temp variable.
   • Next, we assign the value stored in pointer variable b to pointer variable a, effectively initializing a with the initial value of b.
   • After that, we assign the initial value of pointer variable a, stored in the temp variable, to the pointer variable b. 
   • At this point, the values stored in the pointer variables will be swapped.
2. In the main() function, we initialize two integer variables, num1 and num2, with the values 23 and 30, respectively. 
3. We then print these initial values to the console with a string message using the printf() function.
4. Next, we call the swap() function, passing references to num1 and num2 as arguments. This passes the memory addresses of the two variables to the swap function, allowing it to modify their values.
5. After the function returns the swapped values, we print them to the console once again using the printf() function.

Time Complexity: O(1) — The program executes in constant time, as all operations take O(1) time.
Space Complexity: O(1) — The program uses a constant amount of memory.

Pointer Method for Swapping Numbers in C (Using Pointers Without Function)

Pointers enable swapping two integers directly in main(), without creating a separate function. Below is a clear example using pointer variables and a temporary variable.

Code Example:

            #include 
int main(){
    int num1, num2, *ptr1, *ptr2, temp;
    printf("Enter the first number: ");
    scanf("%d", &num1);
    printf("Enter the second number: ");
    scanf("%d", &num2);

    printf("Before swapping:num1 = %d  num2 = %d\n", num1, num2);

    // Initialize pointer variables to the addresses of num1 and num2
    ptr1 = &num1;
    ptr2 = &num2;

    // Swap using dereferenced pointers
    temp   = *ptr1;  // temp = num1
    *ptr1 = *ptr2;   // num1 = num2
    *ptr2 = temp;    // num2 = original num1

    printf("After swapping:num1 = %d  num2 = %d\n", num1, num2);

    return 0;
}

          

I2luY2x1ZGUgPHN0ZGlvLmg+CmludCBtYWluKCl7CiAgICBpbnQgbnVtMSwgbnVtMiwgKnB0cjEsICpwdHIyLCB0ZW1wOwogICAgcHJpbnRmKCJFbnRlciB0aGUgZmlyc3QgbnVtYmVyOiAiKTsKICAgIHNjYW5mKCIlZCIsICZudW0xKTsKICAgIHByaW50ZigiRW50ZXIgdGhlIHNlY29uZCBudW1iZXI6ICIpOwogICAgc2NhbmYoIiVkIiwgJm51bTIpOwoKICAgIHByaW50ZigiQmVmb3JlIHN3YXBwaW5nOm51bTEgPSAlZCAgbnVtMiA9ICVkXG4iLCBudW0xLCBudW0yKTsKCiAgICAvLyBJbml0aWFsaXplIHBvaW50ZXIgdmFyaWFibGVzIHRvIHRoZSBhZGRyZXNzZXMgb2YgbnVtMSBhbmQgbnVtMgogICAgcHRyMSA9ICZudW0xOwogICAgcHRyMiA9ICZudW0yOwoKICAgIC8vIFN3YXAgdXNpbmcgZGVyZWZlcmVuY2VkIHBvaW50ZXJzCiAgICB0ZW1wICAgPSAqcHRyMTsgIC8vIHRlbXAgPSBudW0xCiAgICAqcHRyMSA9ICpwdHIyOyAgIC8vIG51bTEgPSBudW0yCiAgICAqcHRyMiA9IHRlbXA7ICAgIC8vIG51bTIgPSBvcmlnaW5hbCBudW0xCgogICAgcHJpbnRmKCJBZnRlciBzd2FwcGluZzpudW0xID0gJWQgIG51bTIgPSAlZFxuIiwgbnVtMSwgbnVtMik7CgogICAgcmV0dXJuIDA7Cn0K

Explanation:

• In the main() function, we first declare five variables, num1, num2, ptr1, ptr2, and temp. 
• Then, we take input for two numbers from the user and store them in num1 and num2.
• We then initialize the two pointers ptr1 and ptr2 and assign them the addresses of num1 and num2.
• Note that dereferencing (*ptr1, *ptr2) gives us direct access to their values.
• Next, we use a temporary variable temp to perform the classic three-step swap:
1. temp = *ptr1; stores the original num1.
2. *ptr1 = *ptr2; copies num2 into num1.
3. *ptr2 = temp; places the original num1 into num2.

Time Complexity: O(1)
Space Complexity: O(1) — uses only two integer variables, two pointers, and one temporary variable

The memcpy() & Custome Function to Swap Two Numbers in C

The memcpy() function is a standard library function from the string header file. It copies the data from one memory location to another. We can use this function to swap two numbers in C programs, just like in the temporary variable approach.

Here, we define a variable swapping function that uses memcpy(). The example C program below illustrates this approach. 

Code Example:

            #include 
#include  // Include the string.h library for memcpy() function

void swap(int* a, int* b) {
char temp[sizeof(int)];
memcpy(temp, a, sizeof(int));
memcpy(a, b, sizeof(int));
memcpy(b, temp, sizeof(int));
}

int main() {

int a = 16;
int b = 24;
printf("Before swap: a = %d, b = %d\n", a, b);

// Call the swap function with addresses of a and b
swap(&a, &b);
printf("After swap: a = %d, b = %d\n", a, b);

return 0;
}
          

I2luY2x1ZGUgPHN0ZGlvLmg+CiNpbmNsdWRlIDxzdHJpbmcuaD4gLy8gSW5jbHVkZSB0aGUgc3RyaW5nLmggbGlicmFyeSBmb3IgbWVtY3B5KCkgZnVuY3Rpb24KCnZvaWQgc3dhcChpbnQqIGEsIGludCogYikgewpjaGFyIHRlbXBbc2l6ZW9mKGludCldOwptZW1jcHkodGVtcCwgYSwgc2l6ZW9mKGludCkpOwptZW1jcHkoYSwgYiwgc2l6ZW9mKGludCkpOwptZW1jcHkoYiwgdGVtcCwgc2l6ZW9mKGludCkpOwp9CgppbnQgbWFpbigpIHsKCmludCBhID0gMTY7CmludCBiID0gMjQ7CnByaW50ZigiQmVmb3JlIHN3YXA6IGEgPSAlZCwgYiA9ICVkXG4iLCBhLCBiKTsKCi8vIENhbGwgdGhlIHN3YXAgZnVuY3Rpb24gd2l0aCBhZGRyZXNzZXMgb2YgYSBhbmQgYgpzd2FwKCZhLCAmYik7CnByaW50ZigiQWZ0ZXIgc3dhcDogYSA9ICVkLCBiID0gJWRcbiIsIGEsIGIpOwoKcmV0dXJuIDA7Cn0=

Output:

Before swap: a = 16, b = 24
After swap: a = 24, b = 16

Explanation:

In the example C code, we first include the <stdio.h> and <string.h> header files for input/ output and memcpy() function, respectively.

1. We then define a function called swap() that takes two integer pointers, a and b, as parameters. Inside the function-
   • We declare an array of integers, called temp, with the size determined by the sizeof() operator. This will act as the temporary variable for swapping.
   • Then, we use the memcpy() function to copy the memory contents of the variable pointed to by a to the temp variable. This copies the data at the memory location rather than the value of the variable itself.
   • Next, we use memcpy() again to copy the memory contents from b to a. At this point, the variable a will hold the original value of b.
   • Finally, we use memcpy() to copy the memory contents stored in temp (which holds the original value of a) to b, effectively swapping the two values.
2. In the main() function, we initialize two integer variables, a and b, with the values 16 and 24, respectively. 
3. We print these values in the output window before swapping, using the printf() function.
4. Next, we call the swap() function, passing the addresses of variables a and b as arguments. 
5. The function swaps the values, which we then print to the console, as shown above.

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

Note: The complexity analysis above shows that using the memcpy() function for swapping two integers is efficient in terms of both time and space complexity, with both complexities being constant. However, it's worth noting that in practice, other methods, like using a temporary variable or bitwise XOR, might be more commonly used for swapping integers due to their simplicity and efficiency.

One‑Line Method for Swapping Numbers in C (Arithmetic + Assignment)

This method achieves the swap of two integers in a single statement, which is a fun and compact trick, though it comes with important caveats. Look at the example below and note the considerations given after that.

Code Example:

            #include 
    
    int main(){
    int num1, num2;
    printf("Enter the first number: ");
    scanf("%d", &num1);
    printf("Enter the second number: ");
    scanf("%d", &num2);

    printf("Before swapping:num1 = %d  num2 = %d\n", num1, num2);

    // One-line swap – arithmetic & assignment combo
    num1 = (num1 + num2) - (num2 = num1);

    printf("After swapping:num1 = %d  num2 = %d\n", num1, num2);

    return 0;
}
          

I2luY2x1ZGUgPHN0ZGlvLmg+CiAgICAKICAgIGludCBtYWluKCl7CiAgICBpbnQgbnVtMSwgbnVtMjsKICAgIHByaW50ZigiRW50ZXIgdGhlIGZpcnN0IG51bWJlcjogIik7CiAgICBzY2FuZigiJWQiLCAmbnVtMSk7CiAgICBwcmludGYoIkVudGVyIHRoZSBzZWNvbmQgbnVtYmVyOiAiKTsKICAgIHNjYW5mKCIlZCIsICZudW0yKTsKCiAgICBwcmludGYoIkJlZm9yZSBzd2FwcGluZzpudW0xID0gJWQgIG51bTIgPSAlZFxuIiwgbnVtMSwgbnVtMik7CgogICAgLy8gT25lLWxpbmUgc3dhcCDigJMgYXJpdGhtZXRpYyAmIGFzc2lnbm1lbnQgY29tYm8KICAgIG51bTEgPSAobnVtMSArIG51bTIpIC0gKG51bTIgPSBudW0xKTsKCiAgICBwcmludGYoIkFmdGVyIHN3YXBwaW5nOm51bTEgPSAlZCAgbnVtMiA9ICVkXG4iLCBudW0xLCBudW0yKTsKCiAgICByZXR1cm4gMDsKfQ==

Output:

Enter the first number: 22
Enter the second number: 44
Before swapping:num1 = 22  num2 = 44
After swapping:num1 = 44  num2 = 22

Explanation:

• We begin by prompting the user to input two numbers using printf() and store them in respective variables using scanf().
• Then, we use another printf() statement to display the numbers before swapping.
• Next, we use a single-line expression to swap the numbers as follows:
• The sub‑expression (num2 = num1) assigns the original num1 to num2 and evaluates to that original num1.
• Then (num1 + num2) effectively becomes original_num1 + original_num1.
• Subtracting the result of the assignment yields the original num2, which is stored back in num1.
• Meanwhile, num2 has already been updated to the original num1.
• We then print the outcome to the console using another printf() statement.

Time Complexity: O(1)
Space Complexity: O(1) — no additional memory apart from the two variables

⚠️ Considerations:

• Undefined Behavior Risk: This trick manipulates and reads the same variables within one expression, causing undefined behavior in C; compilers are not guaranteed to evaluate sub‑expressions in any consistent order.
• Readability: Though concise, this code is harder to grasp at a glance compared to the standard 3‑step swap—it's more suited for educational curiosity than for production.

Tip: If you encounter compiler warnings, add parentheses or extra steps—or better yet, avoid this idiom altogether in mission‑critical code.

Looking for mentors? Find the perfect mentor for select experienced coding & software experts here.

Conclusion

Swapping of two numbers in C is a common operation that can be performed using many approaches. These include the temporary variable, arithmetic and bitwise operators, pointer variables, and the memcpy() function from the string library. You can choose any of these techniques depending on the resources and specific requirements. 

Also read- 100+ Top C Interview Questions With Answers (2024)

Frequently Asked Questions

Q. What is the swapping of two numbers in C?

Swapping of two numbers in C refers to the process of exchanging the values of two variables, typically integers so that their values are interchanged.

Q. Why do we need to swap two numbers in a C program?

Swapping two numbers is a common programming task often required in various applications, such as sorting algorithms, mathematical operations, and data manipulation, where the values of two variables must be interchanged.

Q. What are the different methods to swap two numbers in C?

There are multiple methods to swap two numbers in C, including using a third variable, using arithmetic operations, and using bitwise XOR operations.

Q. How can we swap two numbers in C without using a third variable?

One common method to swap two numbers in C without using a third variable is by using arithmetic operations, such as addition and subtraction. Another method is using a bitwise XOR operation.

Q. What is the advantage of swapping two numbers without using a third variable?

The advantage of swapping two numbers without using a third variable is that it saves memory space as it avoids the need for an additional variable, which can be useful in situations where memory space is a concern.

Q. Is swapping two numbers in C platform-dependent?

No, swapping two numbers in C using standard C language constructs is platform-independent and can be used on any system that supports the C programming language.

Q. Can swapping two numbers in C result in loss of data or precision?

No, swapping two numbers in C using standard swapping methods, such as using a third variable or arithmetic operations, does not result in any loss of data or precision, as the values are merely exchanged between variables.

Q. Can I use the swapping of two numbers code in my own C programs without any copyright issues?

Yes, the swapping of two numbers in C code is a basic programming logic that is widely used and not subject to copyright issues. However, it's always good practice to acknowledge the source of the code if you refer to any specific implementation from external sources.

This compiles our discussion on the swapping of two numbers in C language. Here are a few other topics you must read:

1. 6 Relational Operators In C & Precedence Explained (+Examples)
2. Typedef In C | Syntax & Use With All Data Types (+ Code Examples)
3. Tokens In C | A Guide For All Types & Their Uses (With Examples)
4. Control Statements In C | The Beginner's Guide (With Examples)
5. Nested Loop In C | For, While, Do-While, Break & Continue (+Codes)