Bagaimanakah saya boleh menjana semua pilih atur yang mungkin bagi pelbagai integer unik menggunakan pendekatan rekursif?

Menjana Pilihatur Tatasusunan

Memahami Masalah

Kami diberi tatasusunan integer unik dan diminta untuk menjana semua pilih atur yang mungkin. Dua pilih atur dianggap berbeza jika ia berbeza dalam susunan unsur. Untuk tatasusunan panjang n, terdapat n! pilih atur yang mungkin.

Pendekatan: Permutasi Rekursif

Penyelesaian melibatkan dua langkah utama:

1. Rekursi: Ambil setiap elemen tatasusunan seterusnya dan permute elemen yang tinggal.
2. Exchange: Tukar elemen semasa dengan elemen dari bahagian yang tinggal untuk mencipta pilih atur baharu.

Menggunakan pendekatan ini, kita boleh menjana semua pilih atur.

Pelaksanaan Kod

import java.util.ArrayList;
import java.util.List;

public class Permutation {

    public static List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        permute(nums, 0, result);
        return result;
    }

    private static void permute(int[] nums, int startIndex, List<List<Integer>> result) {
        if (startIndex == nums.length - 1) {
            // Base case: If we reach the end of the array, add the current permutation to the result.
            List<Integer> permutation = new ArrayList<>();
            for (int num : nums) {
                permutation.add(num);
            }
            result.add(permutation);
        } else {
            // Recursive case: Permute the remaining elements for each element at the current index.
            for (int i = startIndex; i < nums.length; i++) {
                swap(nums, startIndex, i);
                permute(nums, startIndex + 1, result);
                swap(nums, startIndex, i);
            }
        }
    }

    private static void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
}

Contoh Penggunaan

int[] nums = {3, 4, 6, 2, 1};
List<List<Integer>> permutations = Permutation.permute(nums);
for (List<Integer> permutation : permutations) {
    System.out.println(permutation);
}

Output:

[3, 4, 6, 2, 1]
[3, 4, 6, 1, 2]
[3, 4, 2, 6, 1]
[3, 4, 2, 1, 6]
[3, 4, 1, 6, 2]
[3, 4, 1, 2, 6]
[3, 2, 6, 4, 1]
[3, 2, 6, 1, 4]
[3, 2, 4, 6, 1]
[3, 2, 4, 1, 6]
[3, 2, 1, 6, 4]
[3, 2, 1, 4, 6]
[3, 6, 4, 2, 1]
[3, 6, 4, 1, 2]
[3, 6, 2, 4, 1]
[3, 6, 2, 1, 4]
[3, 6, 1, 4, 2]
[3, 6, 1, 2, 4]
[6, 3, 4, 2, 1]
[6, 3, 4, 1, 2]
[6, 3, 2, 4, 1]
[6, 3, 2, 1, 4]
[6, 3, 1, 4, 2]
[6, 3, 1, 2, 4]
[6, 4, 3, 2, 1]
[6, 4, 3, 1, 2]
[6, 4, 2, 3, 1]
[6, 4, 2, 1, 3]
[6, 4, 1, 3, 2]
[6, 4, 1, 2, 3]
[2, 3, 6, 4, 1]
[2, 3, 6, 1, 4]
[2, 3, 4, 6, 1]
[2, 3, 4, 1, 6]
[2, 3, 1, 6, 4]
[2, 3, 1, 4, 6]
[2, 6, 3, 4, 1]
[2, 6, 3, 1, 4]
[2, 6, 4, 3, 1]
[2, 6, 4, 1, 3]
[2, 6, 1, 3, 4]
[2, 6, 1, 4, 3]
[4, 3, 6, 2, 1]
[4, 3, 6, 1, 2]
[4, 3, 2, 6, 1]
[4, 3, 2, 1, 6]
[4, 3, 1, 6, 2]
[4, 3, 1, 2, 6]
[4, 6, 3, 2, 1]
[4, 6, 3, 1, 2]
[4, 6, 2, 3, 1]
[4, 6, 2, 1, 3]
[4, 6, 1, 3, 2]
[4, 6, 1, 2, 3]
[1, 3, 6, 4, 2]
[1, 3, 6, 1, 4]
[1, 3, 4, 6, 1]
[1, 3, 4, 1, 6]
[1, 3, 1, 6, 4]
[1, 3, 1, 4, 6]
[1, 6, 3, 4, 2]
[1, 6, 3, 1, 4]
[1, 6, 4, 3, 1]
[1, 6, 4, 1, 3]
[1, 6, 1, 3, 4]
[1, 6, 1, 4, 3]
[2, 4, 3, 6, 1]
[2, 4, 3, 1, 6]
[2, 4, 6, 3, 1]
[2, 4, 6, 1, 3]
[2, 4, 1, 6, 3]
[2, 4, 1, 3, 6]
[2, 1, 4, 3, 6]
[2, 1, 4, 1, 6]
[2, 1, 6, 4, 3]
[2, 1, 6, 1, 4]
[2, 1, 3, 4, 6]
[2, 1, 3, 1, 6]
[6, 2, 4, 3, 1]
[6, 2, 4, 1, 3]
[6, 2, 1, 4, 3]
[6, 2, 1, 3, 4]
[6, 4, 2, 3, 1]
[6, 4, 2, 1, 3]
[6, 1, 2, 4, 3]
[6, 1, 2, 1, 4]
[6, 1, 4, 2, 3]
[6, 1, 4, 1, 3]
[6, 1, 3, 1, 4]
[6, 1, 3, 4, 1]
[4, 2, 6, 3, 1]
[4, 2, 6, 1, 3]
[4, 2, 1, 6, 3]
[4, 2, 1, 3, 6]
[4, 6, 2, 3, 1]

Atas ialah kandungan terperinci Bagaimanakah saya boleh menjana semua pilih atur yang mungkin bagi pelbagai integer unik menggunakan pendekatan rekursif?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!