在Java中使用荷兰国家排序算法(的switch-case版)三方partioning

给定一个数组列表arr ，其值是lowVal和highVal 。任务是在范围内对数组进行分区，以使数组List分为三部分。

1)所有小于lowVal的元素排在最前面。
2)接下来是在lowVal到highVVal范围内的所有元素。
3)所有大于highVVal的元素都出现在最后。
三组中的各个元素可以按任何顺序出现。您需要返回修改后的排列数组。

注意：这是荷兰国旗算法的切换案例版本，用于三向分区。

例子：

Input: arr[] = {1, 14, 5, 20, 4, 2, 54, 20, 87, 98, 3, 1, 32}  
        lowVal = 14, highVal = 20
Output: arr[] = {1, 5, 4, 2, 1, 3, 14, 20, 20, 98, 87, 32, 54}

Input: arr[] = {1, 14, 5, 20, 4, 2, 54, 20, 87, 98, 3, 1, 32}  
       lowVal = 20, highVal = 20       
Output: arr[] = {1, 14, 5, 4, 2, 1, 3, 20, 20, 98, 87, 32, 54} 

算法：

1. 我们创造 三个变量并将其命名为low = 0，mid = 0，high = arr.size();
2. 现在， 遍历给定的arr直到中点小于或等于高，即；中≤高。
3. 现在创建另一个变量作为value ，这里我们将存储在切换条件下使用的条件。
4. 如果arr.get(mid)那么我们将在该值中存储0 。
5. 如果arr.get(mid)> = lowVal && arr.get(mid)≤highVal)，则在值中存储1 。
6. 如果arr.get(mid)> highVal，那么我们将2存储在该值中。
7. 现在检查开关中的值。
8. 如果它是0，那么我们从arr的中到低以及从低到中的位置交换元素，即； Collections.swap(arr，mid，low)然后增加中和低，即；中++;低++;终于休息了
9. 如果它为1，则我们不会从元素的位置交换元素，因为满足第二个条件的元素，即，如果元素在lowVal和highVal之间，则将其保持不变。根据声明，我们仅交换仅满足第一条件和第三条件的元素。然后增加中间，即；中++;最后，休息。
10. 如果它是2，则我们从arr的中高到高到arr的中间位置交换元素，即； Collections.swap(A，mid，high)然后增加中和高，即mid ++;高++;终于休息了
11. 最后，返回ArrayList arr。

Java

// Dutch National Sort algorithm 
// using switch in Java
  
import java.io.*;
import java.util.*;
  
class GFG {
  
    static ArrayList
    threeWayPartition(ArrayList arr, int lowVal,
                      int highVal)
    {
        // dutch national sort algorithm
        // using switch
        int low = 0, mid = 0, high = arr.size() - 1;
  
        while (mid <= high) {
  
            int value;
  
            // satisfying consition 1
            if (arr.get(mid) < lowVal)
                value = 0;
  
            // satisfying condition 2
            else if (arr.get(mid) >= lowVal
                     && arr.get(mid) <= highVal)
                value = 1;
  
            // satisfying condition 3
            else
                value = 2;
  
            switch (value) {
  
            // incase of first condition, do this
            case 0:
                Collections.swap(arr, mid, low);
                mid++;
                low++;
                break;
  
            // incase of second condition, do this
            case 1:
                mid++;
                break;
  
            // incase of third condition, do this
            case 2:
                Collections.swap(arr, mid, high);
                high--;
                break;
            }
        }
  
        // return the modified arraylist
        return arr;
    }
  
    public static void main(String[] args)
    {
  
        Scanner s = new Scanner(System.in);
  
        // create an empty arraylist
        ArrayList a = new ArrayList<>();
  
        // add elements
        a.add(1);
        a.add(14);
        a.add(5);
        a.add(20);
        a.add(4);
        a.add(2);
        a.add(54);
        a.add(20);
        a.add(87);
        a.add(98);
        a.add(3);
        a.add(1);
        a.add(32);
  
        // stores the modified arraylist
        ArrayList res
            = threeWayPartition(a, 14, 20);
  
        // Output the arraylist
        for (int i = 0; i < 13; i++)
            System.out.print(res.get(i) + " ");
    }
}

输出

1 5 4 2 1 3 14 20 20 98 87 32 54 

• 时间复杂度：O(n)
• 辅助空间：O(1)