Generate All Permutations of Array in DSA C - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a permutation of an array?

A permutation of an array is a rearrangement of its elements in any possible order. For example, for [1, 2], the permutations are [1, 2] and [2, 1].

beginner

What is the base case in a recursive function to generate all permutations of an array?

The base case occurs when the current index reaches the length of the array, meaning a complete permutation has been formed and can be processed or printed.

intermediate

Why do we swap elements during permutation generation?

Swapping elements helps to fix one element at the current position and recursively generate permutations for the remaining positions, ensuring all unique orders are explored.

intermediate

How does backtracking work in generating permutations?

Backtracking restores the array to its previous state after recursive calls by swapping elements back, allowing the algorithm to explore other permutations without side effects.

intermediate

What is the time complexity of generating all permutations of an array of size n?

The time complexity is O(n!), because there are n! (factorial of n) possible permutations to generate and process.

What does the base case in permutation generation check for?

A If the array is sorted

B If the current index equals the array length

C If the array contains duplicates

D If the first element is fixed

The base case is when the current index reaches the array length, meaning a full permutation is ready.

Why do we swap elements back after recursive calls in permutation generation?

A To restore the original array for other permutations

B To sort the array

C To remove duplicates

D To increase the array size

Swapping back restores the array so other permutations can be generated correctly.

How many permutations does an array of size 3 have?

A 3

B 9

C 6

D 12

An array of size 3 has 3! = 6 permutations.

Which technique is commonly used to generate all permutations?

A Backtracking

B Greedy algorithm

C Dynamic programming

D Divide and conquer

Backtracking is used to explore all possible permutations by recursive swapping and restoring.

What is the main purpose of swapping elements in permutation generation?

A To delete elements

B To sort the array

C To reverse the array

D To fix an element at the current position

Swapping fixes one element at the current index to generate permutations of the rest.

Explain how recursion and swapping work together to generate all permutations of an array.

Think about fixing one element at a time and exploring all options for the rest.

Describe the role of backtracking in generating permutations and why it is necessary.

Consider what happens if you don't swap back after recursion.

Practice

1. What does the process of generating all permutations of an array mean?

easy

A. Finding the maximum element in the array

B. Sorting the array in ascending order

C. Listing all possible orders of the array elements

D. Removing duplicate elements from the array

Solution

1. Step 1: Understand permutations

   Permutations are all possible ways to arrange elements in order.

2. Step 2: Apply to array elements

   Generating all permutations means listing every possible order of the array elements.

3. Final Answer:

   Listing all possible orders of the array elements -> Option C

4. Quick Check:

   Permutations = all orders [OK]

Hint: Permutations = all ways to arrange elements [OK]

Common Mistakes:

• Confusing permutations with sorting
• Thinking permutations remove duplicates
• Mixing permutations with finding max/min

2. Which of the following is the correct base case for a recursive function generating all permutations of an array arr of size n?

easy

A. if (start > n) { print(arr); return; }

B. if (start == n) { print(arr); return; }

C. if (n == 0) { return; }

D. if (start == 0) { print(arr); return; }

Solution

1. Step 1: Understand recursion base case

   The base case occurs when the start index reaches the array size, meaning a full permutation is formed.

2. Step 2: Match base case condition

   Condition start == n means all positions are fixed, so print the permutation and return.

3. Final Answer:

   if (start == n) { print(arr); return; } -> Option B

4. Quick Check:

   Base case when start equals array size [OK]

Hint: Base case: start index equals array length [OK]

Common Mistakes:

• Using start > n instead of start == n
• Printing when start == 0 (start of recursion)
• Missing base case leading to infinite recursion

3. What is the output of the following C code snippet?

void permute(int *arr, int start, int n) {
    if (start == n) {
        for (int i = 0; i < n; i++) printf("%d ", arr[i]);
        printf("\n");
        return;
    }
    for (int i = start; i < n; i++) {
        int temp = arr[start];
        arr[start] = arr[i];
        arr[i] = temp;
        permute(arr, start + 1, n);
        temp = arr[start];
        arr[start] = arr[i];
        arr[i] = temp;
    }
}

int main() {
    int arr[] = {1, 2};
    permute(arr, 0, 2);
    return 0;
}

medium

A. 1 2 \n 2 1 \n

B. 1 2 \n 1 2 \n

C. 2 1 \n 1 2 \n

D. No output

Solution

1. Step 1: Trace first call permute(arr, 0, 2)

   Start=0, loop i=0 to 1. Swap arr[0] with arr[0], call permute(arr,1,2).

2. Step 2: Trace second call permute(arr, 1, 2)

   Start=1, loop i=1 to 1. Swap arr[1] with arr[1], call permute(arr,2,2). Base case reached, print "1 2".

3. Step 3: Backtrack and swap arr[0] with arr[1]

   Now arr = {2,1}. Call permute(arr,1,2) again, print "2 1".

4. Final Answer:

   1 2 2 1 -> Option A

5. Quick Check:

   All permutations of [1,2] printed [OK]

Hint: Swap and backtrack to generate permutations [OK]

Common Mistakes:

• Not swapping back after recursive call
• Printing incomplete permutations
• Confusing loop indices

4. Identify the error in the following code snippet that generates permutations of an array arr of size n:

void permute(int *arr, int start, int n) {
    if (start == n) {
        for (int i = 0; i < n; i++) printf("%d ", arr[i]);
        printf("\n");
        return;
    }
    for (int i = start; i < n; i++) {
        int temp = arr[start];
        arr[start] = arr[i];
        arr[i] = temp;
        permute(arr, start + 1, n);
        // Missing swap back here
    }
}

medium

A. Missing swap back after recursive call causes incorrect permutations

B. Base case condition should be start > n

C. Loop should run from i = 0 to n

D. Printing inside base case is incorrect

Solution

1. Step 1: Understand swap and backtrack

   After swapping and recursive call, we must swap back to restore original array for next iteration.

2. Step 2: Identify missing swap back

   The comment shows swap back is missing, so array stays changed, causing wrong permutations.

3. Final Answer:

   Missing swap back after recursive call causes incorrect permutations -> Option A

4. Quick Check:

   Swap back needed to restore array [OK]

Hint: Always swap back after recursion to restore array [OK]

Common Mistakes:

• Forgetting to swap back after recursion
• Changing loop range incorrectly
• Wrong base case condition

5. Given an array arr = {1, 2, 2}, how many unique permutations will a correct algorithm generate that avoids duplicates?

hard

A. 6

B. 2

C. 4

D. 3

Solution

1. Step 1: Calculate total permutations without duplicates

   For 3 elements with two '2's, total permutations = 3! / 2! = 3.

2. Step 2: List unique permutations

   Unique permutations are: [1,2,2], [2,1,2], [2,2,1]. But careful with counting duplicates in generation.

3. Step 3: Consider correct algorithm avoiding duplicates

   Some algorithms generate 4 permutations including one duplicate if not careful, but correct unique count is 3.

4. Final Answer:

   3 -> Option D

5. Quick Check:

   Unique permutations = 3 [OK]

Hint: Use factorial formula with duplicates: n!/k! [OK]

Common Mistakes:

• Counting duplicates as unique permutations
• Ignoring duplicate elements in calculation
• Assuming all permutations are unique