Java 任意长度的'；R''；B''；W'；是否需要按该顺序进行排序

存在长度为n的字符数组。数组只能包含任意顺序R、B、W的元素。 您需要对数组进行排序，使其顺序为R、B、W，即所有R将首先出现在B之后，然后是W。
约束条件：时间复杂度为O（n），空间复杂度应为O（1）。
假设：您可以假设使用签名交换（char[]arr，int index1，int index2）给出了一个交换方法 以单位时间交换数字。
给出的实现方法：公共排序（char[]数组）

这是我的实现。欢迎任何人提供更好的解决方案。如果我有任何错误，任何人都可以随意指出

 public static void sort(char[] arr){
     int rIndex = 0, wIndex = arr.length -1;
     for (int i = 0 ; i <= wIndex; i ++ ){
         if ( arr[i] == 'R' ){
             swap(arr, i , rIndex ++ );
         } else if (arr[i] == 'W' ){
             swap(arr, i , wIndex -- );
         }else if ( arr[i] == 'B' ){
             swap(arr, i , rIndex );
         }
     }
    }

公共静态无效排序（char[]arr）{
int-rIndex=0，wIndex=arr.length-1；
对于（int i=0；i我不确定这个问题是否在SO的范围内，但我将提出一个替代解决方案，主要是因为我发现任务规范令人讨厌。不需要实际的“排序”。）

公共静态无效排序（char[]arr）{
int r=0，b=0，w=0；
对于（int i=0；i0；r--）arr[o++]='r'；
对于（；b>0；b--）arr[o++]='b'；
对于（；w>0；w--）arr[o++]='w'；
}
我不确定这个问题是否在SO的范围内，但我将提出一个替代解决方案，主要是因为我发现任务规范很烦人。不需要实际的“排序”。）

公共静态无效排序（char[]arr）{
int r=0，b=0，w=0；
对于（int i=0；i0；r--）arr[o++]='r'；
对于（；b>0；b--）arr[o++]='b'；
对于（；w>0；w--）arr[o++]='w'；
}
尝试使用交换：

public static void main(String[] args) {
    char[] arr = "WBRBBWBRRBWBR".toCharArray();
    sort(arr);
    System.out.println(String.valueOf(arr));
}
public static void sort(char[] arr) {
    int rCount = sortFirst(arr, 0, 'R');
    sortFirst(arr, rCount, 'B');
}
public static int sortFirst(char[] arr, int offset, char ch) {
    int chCount = 0;
    for (int i = offset; i < arr.length; i++) {
        if (arr[i] == ch) {
            if (i > offset + chCount)
                swap(arr, offset + chCount, i);
            chCount++;
        }
    }
    return chCount;
}
public static void swap(char[] arr, int index1, int index2) {
    char h = arr[index1];
    arr[index1] = arr[index2];
    arr[index2] = h;
}

publicstaticvoidmain（字符串[]args）{
char[]arr=“wbrbwbr.toCharArray（）；
排序（arr）；
System.out.println（String.valueOf（arr））；
}
公共静态无效排序（字符[]arr）{
int rCount=sortFirst（arr，0，'R'）；
排序第一（arr，rCount，'B'）；
}
公共静态int-sortFirst（char[]arr，int-offset，char-ch）{
int-chCount=0；
对于（int i=偏移；ioffset+chCount）
交换（arr，偏移量+chCount，i）；
chCount++；
}
}
返回chCount；
}
公共静态无效交换（char[]arr，int index1，int index2）{
字符h=arr[index1]；
arr[index1]=arr[index2]；
arr[index2]=h；
}
尝试使用交换：

public static void main(String[] args) {
    char[] arr = "WBRBBWBRRBWBR".toCharArray();
    sort(arr);
    System.out.println(String.valueOf(arr));
}
public static void sort(char[] arr) {
    int rCount = sortFirst(arr, 0, 'R');
    sortFirst(arr, rCount, 'B');
}
public static int sortFirst(char[] arr, int offset, char ch) {
    int chCount = 0;
    for (int i = offset; i < arr.length; i++) {
        if (arr[i] == ch) {
            if (i > offset + chCount)
                swap(arr, offset + chCount, i);
            chCount++;
        }
    }
    return chCount;
}
public static void swap(char[] arr, int index1, int index2) {
    char h = arr[index1];
    arr[index1] = arr[index2];
    arr[index2] = h;
}

publicstaticvoidmain（字符串[]args）{
char[]arr=“wbrbwbr.toCharArray（）；
排序（arr）；
System.out.println（String.valueOf（arr））；
}
公共静态无效排序（字符[]arr）{
int rCount=sortFirst（arr，0，'R'）；
排序第一（arr，rCount，'B'）；
}
公共静态int-sortFirst（char[]arr，int-offset，char-ch）{
int-chCount=0；
对于（int i=偏移；ioffset+chCount）
交换（arr，偏移量+chCount，i）；
chCount++；
}
}
返回chCount；
}
公共静态无效交换（char[]arr，int index1，int index2）{
字符h=arr[index1]；
arr[index1]=arr[index2]；
arr[index2]=h；
}
没关系，这是我上述算法的改进版本。它少了一次交换调用，并且使用了开关，而不是if-else块

public static void sort(char[] arr){
     int rIndex = 0, wIndex = arr.length -1;
     for (int i = 0 ; i <= wIndex;){
        switch(arr[i]){
          case 'R':
            swap(arr, i, rIndex ++ );
            i ++;
            break;
          case 'W':
            swap(arr, i, wIndex -- );
            break;
          case 'B':
            i ++;
            break;
          default: 
             throw new IllegalArguementException(arr[i] + " is not allowed in the array");

       }
   }
}

公共静态无效排序（char[]arr）{
int-rIndex=0，wIndex=arr.length-1；
对于（inti=0；i没关系，这里是我上述算法的改进版本。它少了一个交换调用，并且使用开关而不是if-else块

public static void sort(char[] arr){
     int rIndex = 0, wIndex = arr.length -1;
     for (int i = 0 ; i <= wIndex;){
        switch(arr[i]){
          case 'R':
            swap(arr, i, rIndex ++ );
            i ++;
            break;
          case 'W':
            swap(arr, i, wIndex -- );
            break;
          case 'B':
            i ++;
            break;
          default: 
             throw new IllegalArguementException(arr[i] + " is not allowed in the array");

       }
   }
}

公共静态无效排序（char[]arr）{
int-rIndex=0，wIndex=arr.length-1；
对于（int i=0；i最快的排序可能是
快速排序
，它的时间效率是
O（n logn）
作为平均值和最坏情况
O（n*n）
。如果已经排序，则最佳情况
O（n）

要获得您想要的效率是不可能的。
你首先要做的是做一个比较两个字符的方法，然后在那里做你的算法，然后做一个交换字符的方法

如果你想达到这样的效率，你不必对它们进行排序。你必须像@Dolda2000那样对它们进行计数并按照你想要的顺序构建一个字符数组。你的排序速度不能超过
快速排序
最快的排序可能是
快速排序
，它的时间效率是
O（n log n）
作为平均和最坏情况
O（n*n）
。如果已排序，则为最佳情况
O（n）

要获得您想要的效率是不可能的。
你首先要做的是做一个比较两个字符的方法，然后在那里做你的算法，然后做一个交换字符的方法

如果你想达到这样的效率，你不必对它们进行排序。你必须像@Dolda2000那样对它们进行计数并按照你想要的顺序构建一个字符数组。你的排序速度不能超过
快速排序
如果你的代码没有问题，那么这就与堆栈溢出无关。如果你需要更多的眼睛，你可以试着问一下。嗯，但是有问题。例如，
swap（）
根据赋值只接受两个参数。（但我没有得到
rIndex++
，
wIndex--
和
rIndex
参数…）.实际上，我不明白这个程序应该如何工作。@TimPietzcker交换方法需要三个参数来交换。这是一个错误。我只是编辑了一下。这不是吗？我认为你不需要在所有三种
if
条件下
交换
。这个问题似乎离题了，因为它是关于请求帮助的五谷