如何计算对字符串进行的字母交换次数？答案

【问题标题】：How do i count the number of letter swaps made to the string?如何计算对字符串进行的字母交换次数？
【发布时间】：2022-01-24 00:12:18
【问题描述】：

我希望我的程序计算发生的字符交换次数，以便按字母顺序排列它们。有什么简单的方法可以做到这一点吗？这是我的代码。

import java.util.Arrays;
import java.util.Scanner;

class ArrangingBooks{
public static void main(String[] args) {
     Scanner scan= new Scanner(System.in);
     String str = scan.nextLine();
     char c[] = str.toCharArray();
     Arrays.sort(c);
     System.out.println(new String(c));

     scan.close();
}
}

样本输入 = LLSLM

样本输入的输出 = 2

【问题讨论】：

这取决于你的排序算法。您是在交换彼此相邻的字符还是交换字符串中的任意两个字符？
按字母顺序交换它们。 A-Z
我认为练习的重点是编写自己的排序例程并自己计算交换次数。
您的技术是否提供字母顺序？也许试试“aAbC”？
如果您可以按字母顺序对数组进行排序，那么您就有 2 个具有相同元素的数组。您可以计算将 1 个数组变为另一个数组所需的交换次数。它不一定是使用的排序算法的交换。

标签： java string swap

【解决方案1】：

Arrays.sort 会选择最优化的排序算法，但除非您修改 Arrays 包，否则您将无法跟踪这些步骤。

或者，您可以实现自己的排序代码，或者从在线复制/粘贴一个，然后添加一个整数计数器，以在每次排序循环迭代时递增。然后你就可以得到每个输入的步数。

【讨论】：

【解决方案2】：

您可以创建一个二维array 来存储每个codePoint 及其index。然后你可以排序array比较codePoints：

public static int countSortedSwaps(String str) {
    int[] arr = str.codePoints().toArray();
    int size = arr.length;
    
    int[][] charIndices = IntStream.range(0, size).boxed()
            .sorted(Comparator.comparingInt(i -> arr[i]))
            .map(i -> new int[] {arr[i], i})
            .toArray(int[][]::new);
   
    boolean[] swp = new boolean[size];
    
    return IntStream.range(0, size)
            .filter(i -> swp[i] != true && charIndices[i][1] != i)
            .map(i -> count(charIndices, swp, i)).sum();
}

private static int count(int[][] charIndices, boolean[] swp, int index) {
    int count = 0;
    int i = index;
    while (swp[i] == false) {
        swp[i] = true;
        count++;
        i = charIndices[i][1];
    }
    return (count - 1);
}

【讨论】：

【解决方案3】：

我很好奇，所以我实现了一种计算交换以从一个数组到另一个数组的方法。

import java.util.Arrays;

public class CountSwaps{
    static int countSwaps( char[] original, char[] sorted){
        int swaps = 0;
        for(int i = 0; i<original.length; i++){
            if(original[i] != sorted[i]){
                for(int j = i+1; j<original.length; j++){
                    if(original[i] == sorted[j]){
                        sorted[j] = sorted[i];
                        sorted[i] = original[i];
                        swaps++;
                        break;
                    }
                }
                
            }
        }
        return swaps;
    }
    public static void main(String[] args){
        String obj = args[0].toLowerCase();
        char[] original = obj.toCharArray();
        char[] sorted = obj.toCharArray();
        Arrays.sort(sorted);
        System.out.println(Arrays.toString(sorted));
        System.out.println(countSwaps(original, sorted));
        System.out.println(Arrays.toString(sorted));
        System.out.println(Arrays.toString(original));
    }

}

然后我们就可以运行它了

java CountSwaps.java TheQuickBrownFoxJumpedOverTheTwoLazyDogs

[a，b，c，d，d，e，e，e，e，f，g，h，h，i，j，k，l，m，n，o，o，o，o， o、p、q、r、r、s、t、t、t、u、u、v、w、w、x、y、z]
35
[t，h，e，q，u，i，c，k，b，r，o，w，n，f，o，x，j，u，m，p，e，d，o，v，e , r, t, h, e, t, w, o, l, a, z, y, d, o, g, s]
[t，h，e，q，u，i，c，k，b，r，o，w，n，f，o，x，j，u，m，p，e，d，o，v，e , r, t, h, e, t, w, o, l, a, z, y, d, o, g, s]

将排序后的数组转换回原始数组需要 35 次交换。这并不反映使用的排序算法进行的交换次数。它也不是最佳的。例如，它需要 37 次交换才能走另一条路，如果它是最优的，它将是对称的。

【讨论】：