Temp Variable
Classic
Save, overwrite, restore.
Swap Two Numbers in C
Overview
What You’ll Learn
Swapping exchanges two variables so each holds the other’s old value: a=5, b=10 becomes a=10, b=5. You will use a temp variable in main, a pointer-based helper function, and an optional XOR trick for integers — plus a live preview and worked examples.
Pointer Swap
int *a, *b
Swap the caller's variables.
XOR Trick
Integers
Interview curiosity, not style.
No Data Loss
Order
Save before you overwrite.
Live Preview
Try 5 & 10
Swap custom integers instantly.
O(1)
All variants
Constant time and space.
Introduction
Swapping means exchanging the values of two variables without losing either one. If you write a = b first, the old a is gone forever — that is why beginners learn a temporary holder.
In C, a function must take int * pointers (or you swap plain variables inside main). Interviews love the classic three-step swap because it shows up in sorting and every systems language.
Why it matters?
Swap is a building block for sorting, partitioning, and many in-place algorithms.
Key Highlights
Save First
temp holds a copy.
Pointers
Pass &num1, &num2.
XOR Caveat
Integers only.
Equal OK
7, 7 stays 7, 7.
In short: exchange values without losing either — prefer temp (and pointers inside helpers) in C.
Foundation
📝 Problem & Approach
Given two variables, exchange their values so each holds what the other used to hold.
c
/* Before: a = 5, b = 10 */
/* After: a = 10, b = 5 */Inputs & Outputs
| Item | Type | Description |
|---|---|---|
a, b | int | Values to exchange (XOR needs integer types). |
| Result | same types | a holds old b; b holds old a. |
temp | same as a | Optional holding spot. |
Minimal workflow
Pseudocode
temp = a
a = b
b = tempMethod comparison
| Method | Idea | Notes |
|---|---|---|
| Temp variable | Save, overwrite, restore | Universal across languages |
| Pointers | swap(int *a, int *b) | Needed outside main |
| XOR | a ^= b; b ^= a; a ^= b | Integers; interview trick |
Cheat Sheet
⚡ Quick Reference
| Goal | Pattern |
|---|---|
| Temp save | temp = a |
| Overwrite | a = b |
| Restore | b = temp |
| Pointers | swap(&x, &y) |
| XOR (ints) | a ^= b; b ^= a; a ^= b |
| Equal values | Swap still correct; no visible change |
Compare
📋 Temp vs Pointers vs XOR
Same result — different packaging.
Temp
temp = aClearest cross-language idea
Pointers
*a / *bNeeded for a swap function
XOR
a ^= bIntegers only; less readable
Wrong
a = b firstLoses the old a
Context
When This Problem Shows Up
Reach for a swap whenever two values need to trade places in place.
Interview basics
First assignment / memory drill.
Sorting steps
Bubble / selection / partition swaps.
Array elements
temp = arr[i]; arr[i] = arr[j]; arr[j] = temp;
Cross-language interviews
Temp swap proves shared concepts.
Not for XOR on floats
Stick to temp then.
Key benefit: one tiny idea — save before overwrite — that shows up in almost every in-place algorithm.
Interactive
🔮 Live Preview
Enter two integers and swap them with a temporary variable (same idea as the C examples).
Hands-On
Examples Gallery
Three complete C programs — temp in main, a pointer helper, and XOR for integers. Click View Output to reveal sample console results.
📚 Getting Started
The classic three-step swap that works in almost every language.
Example 1 — Swap Using Temp Variable
Save the first value, overwrite it, then restore into the second variable — all inside main.
c
#include <stdio.h>
int main(void) {
int num1 = 5;
int num2 = 10;
int temp;
printf("Before swapping: num1 = %d, num2 = %d\n", num1, num2);
temp = num1;
num1 = num2;
num2 = temp;
printf("After swapping: num1 = %d, num2 = %d\n", num1, num2);
return 0;
}How It Works
temp keeps 5 while num1 becomes 10. Then num2 receives the saved 5. No pointers needed when everything lives in one function.
⚡ The C Way
A helper needs pointers so the caller’s variables actually change.
Example 2 — Swap Using Pointers
Classic interview style: pass addresses so the swap survives after the function returns.
c
#include <stdio.h>
void swapNumbers(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
int main(void) {
int num1 = 5;
int num2 = 10;
printf("Before swapping: num1 = %d, num2 = %d\n", num1, num2);
swapNumbers(&num1, &num2);
printf("After swapping: num1 = %d, num2 = %d\n", num1, num2);
return 0;
}How It Works
&num1 passes the address of num1. Inside the function, *a reads or writes the original variable. A plain void swap(int x, int y) would only swap copies.
Example 3 — Swap Without Temp (XOR Trick)
Works for integers. Prefer temp in real C code; keep XOR as an interview curiosity. Guard when both pointers are the same address.
c
#include <stdio.h>
void swapXor(int *a, int *b) {
if (a == b) {
return;
}
*a ^= *b;
*b ^= *a;
*a ^= *b;
}
int main(void) {
int num1 = 5;
int num2 = 10;
printf("Before swapping: num1 = %d, num2 = %d\n", num1, num2);
swapXor(&num1, &num2);
printf("After swapping: num1 = %d, num2 = %d\n", num1, num2);
return 0;
}How It Works
Three XOR steps rearrange the bit patterns so a and b trade places. The a == b address guard avoids wiping a value to 0 when both parameters point at the same variable.
🧠 How the Temp Swap Works
1
temp = a
Save the first value.
Hold
2
a = b
Copy the second into the first.
Overwrite
3
b = temp
Restore the saved value into b.
Restore
=
Values exchanged
Neither original was lost.
Trace
🔎 Worked Walkthrough — 5 and 10
Follow the temp variable through each assignment.
| Step | a | b | temp |
|---|---|---|---|
| start | 5 | 10 | — |
| temp = a | 5 | 10 | 5 |
| a = b | 10 | 10 | 5 |
| b = temp | 10 | 5 | 5 |
If you assign a = b first without saving, the original 5 disappears.
Use Cases
Where swaps show up beyond the interview prompt.
1. Interview Warm-ups
Assignment and memory basics.
Example: temp swap of 5, 10.
2. Sorting Algorithms
Bubble and selection swaps.
Example: adjacent pairs.
3. List Elements
temp between arr[i] and arr[j].
Example: in-place reorder.
4. Partition Steps
Quicksort-style exchanges.
Example: pivot swaps.
5. Teaching Memory
Why overwrite order matters.
Example: walkthrough table.
6. Next: Triangular
Continue the interview chain.
Example: related CTA.
Pro Tip: say “save before overwrite” before you write the three lines.
Advantages
Why learning all three approaches is useful.
1. Temp Is Portable
Same idea in C, Java, JS, and more.
2. Pointers Are Explicit
Helpers change the caller’s variables.
3. Constant Cost
O(1) time and space for all variants.
4. XOR Shows Bit Tricks
Useful trivia once you know the readable form.
Pro Tip: lead with temp (and pointers in helpers); mention XOR only if asked about “without a temp”.
Usage Tips
Small habits that keep swap solutions interview-ready.
1. Save Before Overwrite
Never a = b as the first step alone.
2. Prefer Temp in C
Use pointers when the swap lives in a helper.
3. Print Before and After
Makes demos and debugging clearer.
4. Keep XOR Optional
Integers only; mention readability cost.
5. Test Equals
7, 7 should remain 7, 7.
Pro Tip: sanity-check (5, 10), (7, 7), and (-4, 20) — if those three work, you are solid.
Common Pitfalls
Mistakes that commonly break swap programs.
1. Overwriting Too Soon
Writing a = b without saving a.
→ Use temp or pointer swap.
2. XOR on Non-Integers
Floats and strings do not XOR.
→ Use temp instead.
3. Incomplete XOR Chain
Missing one of the three ^= steps.
→ Prefer
tempin C.4. Thinking Equals Is Broken
Expecting failure when a == b.
→ Swap is still correct.
5. Forcing XOR in Production
Clever but harder to maintain.
→ Use the readable form.
Edge Cases
Handle these before claiming the swap is complete.
Same values
No visible change
Swap is still correct.
XOR caveat
Integers only
Temp (or pointer + temp) is preferred in C.
Negatives
Temp / pointers OK
-4 and 20 swap fine.
Zeros
Valid
0, 3 becomes 3, 0.
Strings / floats
Use temp
Skip XOR.
Array indices
Same pattern
arr[i], arr[j] = arr[j], arr[i]
Theory
⚖️ Facts Worth Knowing
Handy follow-ups interviewers sometimes ask.
- Sorting building block. Almost every in-place sort swaps elements.
- Pointers need
*. That is why a helper takesint *addresses. - XOR is optional trivia. Prefer readability unless asked specifically.
- All variants are O(1). Cost does not grow with the numbers’ magnitude.
Drill
🎯 Practice Problems
Try these variations to lock in the pattern.
1. Temp swap 5, 10
- Reproduce Example 1
- Expect 10, 5
2. Pointer swap
- Call swapNumbers(&a, &b)
- Same result
3. Equal values
- Swap 7, 7
- Confirm still 7, 7
4. Array indices
- Swap arr[0] and arr[1]
- Use a temp variable
Important
Notes
- Core idea: exchange values without losing either one.
- C helpers: take
int *and usetemp. - XOR: mainly an interview trick for integers.
- All swap variants are constant-time and constant extra space.
Quick Takeaway: save before overwrite — use pointers when swapping inside a function.
Analysis
⏱️ Time and Space Complexity
| Version | Time | Extra space |
|---|---|---|
| Temp swap | O(1) | O(1) |
| Pointer swap | O(1) | O(1) |
| XOR swap | O(1) | O(1) |
Swapping two variables does a fixed number of assignments regardless of the values.
🎉 Conclusion
Swapping exchanges two values without losing either one. Learn the temp-variable pattern, use pointers for a reusable swap function, and treat XOR as optional trivia.
Practice the three examples above, then continue to triangular numbers.
Save first — pass addresses into helpers.
Pro Tips
💡 Best Practices
✅ Do
- Save before overwrite
- Use pointers for swap helpers
- Print before and after
- Know the temp pattern
- Test equal values
❌ Don’t
- Assign a = b first alone
- XOR floats or strings
- Skip readability for cleverness
- Assume equals breaks swap
- Forget pass-by-value copies do not swap callers
Summary
Key Takeaways
Knowledge Unlocked
Five things to remember about swapping
Exchange values safely — then use the idea in sorting.
5
Core concepts 01
Temp
save / set / restore
Classic 02
Pointers
*a / *b + temp
C 03
XOR
ints only
Trick 04
Equals
still correct
Edge 05
Cost
O(1)
Analysis❓ Frequently Asked Questions
After swapping, the first variable stores the old value of the second, and the second stores the old value of the first.
If you write a = b first, you lose the old value of a before you can copy it into b. A spare box called temp remembers the first value while you move things around.
Plain integers are passed by value: the function would only swap its own copies. Pointers tell C where the original variables live in memory, so the caller sees the change.
Yes for integers, but it is less readable than a temp variable, so it is mostly an interview trick. Guard against both pointers referring to the same address.
Swap still works; values remain the same.
Yes. Temp and pointer swaps work for any int values; XOR is for integer types only.
All common swap variants are O(1) time and O(1) extra space.
Show temp in main first, then the pointer version, then mention XOR as optional trivia.
Did you Know? 🔊
Swapping values is one of the smallest building blocks in sorting. In C, the three-line pattern with a temp variable (and pointers when swapping inside a function) is the clearest everyday approach.
Continue to Triangular Number
Learn how to check whether a number is triangular in C.
About the author
8 people found this page helpful