chapter1

1、编写递归例程 void permute(String str) 显示字符串str的所有字符排列

1）、boolean数组记录字符是否使用，pos记录已使用的字符

• 基准情况：字符均已使用，打印出字符串
• 不断推进：StringBuilder拼接当前字符，记录占用，递归进入下一层

private boolean[] vis;

private int n;

public void permute(String str) {
    if (str == null || str.length() < 2)
        return;
    char[] arr = str.toCharArray();
    vis = new boolean[arr.length];
    n = str.length();
    permute(arr, 0, new StringBuilder());
}

private void permute(char[] arr, int pos, StringBuilder sb) {
    if (pos == n) {
        System.out.println(sb);
        return;
    }
    for (int i = 0 ; i < n; i++) {
        if (vis[i])
            continue;
        sb.append(arr[i]);
        vis[i] = true;
        permute(arr, pos + 1, sb);
        sb.deleteCharAt(sb.length() - 1);
        vis[i] = false;
    }
}

2)、“下一个更大的排序”算法递归

• 基准情况：当前字符数组已经逆序排序
• 不断推进：递归获取当前字符数组下一个更大的排序

public void permute(String str) {
    if (str == null || str.length() < 2)
        return;
    char[] nums = str.toCharArray();
    Arrays.sort(nums);
    nextPermutation(nums);
}

public void nextPermutation(char[] nums) {
    int n = nums.length - 2;
    while (n > -1 && nums[n] >= nums[n + 1]) {
        n--;
    }
    if (n < 0)
        return;
    int i = nums.length - 1;
    while (i > n + 1 && nums[i] <= nums[n])
        i--;
    swap(nums, n, i);
    reserve(nums, n + 1);
    System.out.println(nums);
    nextPermutation(nums);
}

private void swap(char[] nums, int left, int right) {
    char temp = nums[left];
    nums[left] = nums[right];
    nums[right] = temp;
}

private void reserve(char[] nums, int left) {
    for (int right = nums.length - 1; left < right; left++, right--) {
        char temp = nums[left];
        nums[left] = nums[right];
        nums[right] = temp;
    }
}

力扣