它出现在这里 cheese 值需要移到数组的开头，只要这里只使用两个值， rearrange 方法可以写成：

public static void rearrange (shoppingList[] shopping) {
        int cheesePos = 0;
        int n = shopping.length;
        // move all cheese to the start
        for (int i = 0; i < n; i++) {
            if (shopping[i] == shoppingList.cheese) {
                shopping[cheesePos++] = shoppingList.cheese;
            }
        }
        // fill the rest with milk
        while (cheesePos < n) {
            shopping[cheesePos++] = shoppingList.milk;
        }
    }

当且仅当数组包含2个不同的元素时，该算法才适用于o（n）。首先，应该将两个不同的元素转换为0或1。

//Driver
public static void main(String[] args) { 

      int arrOfValues[] = { 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1 };

      sortArray(arrOfValues, arrOfValues.length); 

      //print array
      for (int loopInt : arrOfValues) {

          System.out.print(loopInt + " "); 
      }
}

static void sortArray(int arr[], int n) {

    int valueFor0 = 0; 
    int valueFor1 = n - 1; 

    while (valueFor0 < valueFor1) { 

        if (arr[valueFor0] == 1) { 

            // swap type0 and type1 
            arr[valueFor0] = arr[valueFor0] + arr[valueFor1]; 
            arr[valueFor1] = arr[valueFor0] - arr[valueFor1]; 
            arr[valueFor0] = arr[valueFor0] - arr[valueFor1]; 
            valueFor1--; 

        } else { 

            valueFor0++; 
        } 
    } 
}

由于只有枚举，从技术上讲，枚举没有对象标识，可以表示为整数，因此通常的比较排序（例如快速排序）不是最佳方法，因为它不会比 O(n long n) .
非比较排序将更快（例如，基数排序将更快） O(w n) )但在这个问题中，只有两个不同的值，所以排序可以在单个数组中完成 O(n) .
您可以将其实现为：
使用计数器迭代数组 i .
每次您发现一个milk时，都会将它与数组中最后一个不是milk的元素交换。
把牛奶放在柜台里，记住最后有多少元素是牛奶 j .
什么时候停止 i 达到 j .
所以可能是这样的：

enum Food { MILK, CHEESE };

void sortMilkLast(Food[] arr) {
    int i = 0;
    int j = arr.length - 1;
    while (j >= 0 && arr[j] == MILK) {
        j--; // avoid swapping MILK already in place
    }
    while (i <= j) {
        if (arr[i] == MILK) {
            arr[i] = arr[j]; // this should always be a CHEESE
            arr[j] = MILK;
            j--;
            while (j >= 0 && arr[j] == MILK) {
                j--; // avoid swapping MILK already in place
            }
        }
        i++;
    }
}

请记住，复杂性不是性能，对于小数组（例如5个元素），方法的不同对排序时间的影响很小。