Java 四种颜色的荷兰国旗算法

我用了两种和三种颜色的解决方案，但四种颜色的解决方案我都没有

请帮忙

它将是

rrbb？？？yyyyggg

？ 我们如何交换绿旗

我尝试了下面的解决方案，但无法将最后一个黄色替换为绿色

  public class count123 {

// Java program to sort an array of 0, 1 and 2,3

    static void sort0123(int a[], int arr_size)
    {
        int lo = 0;
        int hi = arr_size - 1;
        int mid = 0,temp=0;
        int h2=arr_size - 1;
        while (mid <= hi)
        {
            switch (a[mid])
            {
            case 0:
            {
                temp = a[lo];
                a[lo] = a[mid];
                a[mid] = temp;
                lo++;
                mid++;
                break;
            }
            case 1:
                mid++;
                break;
            case 2:
            {
                temp = a[mid];
                a[mid] = a[hi];
                a[hi] = temp;

                hi--;
                h2=hi;
                break;
            }
            case 3:{
                temp = a[mid];
                a[mid] = a[h2];
                a[h2] = temp;
            //  h2--;
                //hi=h2;
                break;

            }
            }
        }
    }

    /* Utility function to print array arr[] */
    static void printArray(int arr[], int arr_size)
    {
        int i;
        for (i = 0; i < arr_size; i++)
            System.out.print(arr[i]+" ");
            System.out.println("");
    }

    /*Driver function to check for above functions*/
    public static void main (String[] args)
    {
        int arr[] = {0, 1, 0,1,2,2,0,3,3,0,0,1};
        int arr_size = arr.length;
        sort0123(arr, arr_size);
        System.out.println("Array after seggregation ");
        printArray(arr, arr_size);
    }
}
/*This code is contributed by Devesh Agrawal*/

公共类count123{
//对0、1和2、3数组进行排序的Java程序
静态无效sort0123（内部a[]，内部arr_大小）
{
int-lo=0；
int hi=arr_尺寸-1；
int mid=0，temp=0；
int h2=arr_大小-1；
而（mid我运行了你的代码，意识到你的代码进入了无限循环，这让你的程序什么都不做

在main方法中，调用了
sort0123（arr，arr_size）；
，在该方法中，
while（mid关于荷兰国旗聚合的要点是始终保持不变量。在0000…11..XXX..222等状态下

lo将始终位于第一个“1”（如果存在）
mid总是在第一个未知的位置
嗨，总是在最后一个未知的时刻
对于4种颜色变化，假设您按照代码中的顺序0,1,3,2进行排序，则需要调整规则，如下所示：

嗨，总是在最后3点
h2总是在最后一个未知的位置
按照上述规则，需要通过以下方式更改代码：

while（mid这是我用python编写的解决方案。其基本原理是将第四种颜色（右中颜色）压缩到左中子数组和右中子数组之间。它随着算法的进行定义颜色

它具有O（n）时间复杂度和O（1）空间复杂度

输入导入列表中的

def dutch_variant_四种颜色（数组：List[int]）->List[int]：
左=数组[0]
中左=无
右=无
左i=0
中左i=0
中\u右\u i=len（阵列）
右_i=len（数组）
而中左右和中左右：
if（数组[mid_left_i]==left）：
数组[mid_left_i]，数组[left_i]=数组[left_i]，数组[mid_left_i]
中左i+=1
左i+=1
elif（右为无或数组[mid_left_i]==右）：
右_i-=1
中右=右
数组[mid_left_i]，数组[right_i]=数组[right_i]，数组[mid_left_i]
右=数组[右]
否则：#它是一个中间值
如果（左中为无）：
mid_left=数组[mid_left_i]
if（数组[mid_left_i]==mid_left）：
中左i+=1
其他：
中右翼i-=1
数组[mid_left_i]、数组[mid_right_i]=数组[mid_right_i]、数组[mid_left_i]
返回数组
#示例用法
印刷（荷兰语变体四种颜色（[1,1,3,3,4,3,2]））
印刷（荷兰语变体四种颜色（[1,2,3,4,2,3,1,3]））
印刷（荷兰语变体四种颜色（[1,2,3,4,4]））
印刷（荷兰语变体四种颜色（[0,1,2,5,5,2,2,0]））
印刷（荷兰语变体四种颜色（[1,0,3,0,5,5]））
印刷（荷兰语变体四种颜色（[1,2,3,2,5,1,1,3]））
印刷（荷兰语变体四种颜色（[5,1,2,3,2,1,1,3]））
印刷（荷兰语变体四种颜色（[3,2,5,1]））
印刷（荷兰语变体四种颜色（[3,2,1,5]））
印刷品（荷兰语变体四种颜色（[3,2,1,3,5,2,2,1,2,3,5,3,2,3,3,2,2,2,5,5,5,3,3,3,3,2,5,3,1,2,2,1,3,2,2,2,2,3,2,2,2,2,2,3,3,3,3,2,2,2,2,1,2,1,2,1,3]））

荷兰国旗上提供了N个不同值的信息
//O（n）优化解。
//O（1）x为不同颜色时所需的空间（不会随着值数量的增加而改变）
public static void DutchNationalFlagforNvaluesOptimized（int distinctFlags，int[]标志）
{
int high=distinctFlags-1，mid=distinctFlags-2；
int[]indexArr=新的int[distinctFlags]；
对于（int i=0；i
让a:string[]=['1'，'2'，'1'，'0'，'2'，'4'，'3'，'0'，'1'，'3']；
函数sort3（a:string[]）：void{
设low=0；
设mid1=0；
设mid2=0；
设mid3=0；
设高=a.长度-1；
而（mid3

#包括
使用名称空间std；
无效DutchNationalFlag4（内部*arr，内部n）
{
int low=0，mid1=0，mid2=n-1，high=n-1；
内部温度；
//这类问题最好用不变量来解决
//arr[0..low-1]conatins 0
//arr[low..mid1-1]包含1
//arr[mid1..mid2]未知
//arr[mid2+1…high-1]包含2个
//arr[high..n-1]包含3个
//终止条件：Evert迭代未知长度减小，因此最终将为零
while（mid1）为什么要以如此复杂的方式进行排序？要么编写/使用能够处理任何整数的适当排序算法，要么如果确实只需要4个值，则使用最简单的桶排序（计算列表中有多少0,1,2,3，然后相应地重新创建）.可能重复我知道，但我无法获得解决方案this@coder25老实说，我不明白你的要求。如果你能更详细地编辑你的问题，我可能会帮助你更好。@coder25你也可以看看下面的问题。他的
case 2:
        {
            temp = a[mid];
            a[mid] = a[hi];
            a[hi] = temp;

            hi--;
            h2--;
            break;
        }
case 3:{
            temp = a[mid];
            a[mid] = a[h2];
            a[h2] = temp;
            h2--;
            break;

        }

//Dutch National Flag for N different values Optimized 
//O(n) optimized solution.
//O(1) space needed where x is distinct colors (it will not change as no. of values increases)

public static void DutchNationalFlagforNvaluesOptimized(int distinctFlags, int[] flags)
        {
            int high = distinctFlags - 1, mid = distinctFlags - 2;

            int[] indexArr = new int[distinctFlags];
            for (int i = 0; i < high; i++)
            {
                indexArr[i] = 0;
            }
            indexArr[high] = flags.Length - 1;// index Array is distinct flags indexes


            for (; indexArr[mid] <= indexArr[high]; )
            {
                if (flags[indexArr[mid]] == high)
                {
                    int temp = flags[indexArr[high]];
                    flags[indexArr[high]] = flags[indexArr[mid]];
                    flags[indexArr[mid]] = temp;

                    indexArr[high]--;
                }
                else
                    if (flags[indexArr[mid]] == mid)
                    {
                        indexArr[mid]++;
                    }
                    else
                    {
                        int currentMidValue = flags[indexArr[mid]];

                        for (int i = mid; i > currentMidValue; i--)
                        {
                            int temp = flags[indexArr[i]];
                            flags[indexArr[i]] = flags[indexArr[i - 1]];
                            flags[indexArr[i - 1]] = temp;
                            indexArr[i]++;
                        }
                        indexArr[currentMidValue]++;
                    }
            }
            for (int i = 0; i < flags.Length; i++)
            {
                System.Console.Write(flags[i] + ", ");
            }
        }

let a:string[] = ['1','2','1','0','2','4','3','0','1','3'];
    function sort3(a:string[]):void{
        let low = 0;
        let mid1 = 0;
        let mid2 = 0;
        let mid3 = 0;
        let high = a.length - 1;
        while(mid3<=high){
            switch(a[mid3]){
                case '0': [a[mid3],a[low]] = [a[low],a[mid3]];
                        low++;
                        if(mid1 < low)
                        mid1++;
                        if(mid2 < mid1)
                        mid2++;
                        if(mid3 < mid2)
                        mid3++;
                        break;

                case '1': [a[mid3],a[mid1]] = [a[mid1],a[mid3]];
                        mid1++;
                        if(mid2 < mid1)
                        mid2++;
                        if(mid3 < mid2)
                        mid3++
                        break;

                case '2': [a[mid2],a[mid3]] = [a[mid3],a[mid2]];
                            mid2++;
                            mid3++;
                       break;

                case '3':
                        mid3++;break;

                case '4': [a[mid3],a[high]] = [a[high],a[mid3]];
                            high--;
            }
        }
    }

#include <iostream>
using namespace std;



void DutchNationalFlag4(int * arr , int n )
{
    int low = 0 , mid1 = 0 , mid2 = n- 1 , high = n-1 ;
    int temp;
 
    // This type of problems are best solved by using invariants 
 
    // arr[ 0 .. low -1 ] conatins 0
    // arr[ low .. mid1 -1 ] contains 1
    // arr[ mid1 .. mid2 ] is unknown
    // arr[ mid2 + 1 ... high - 1 ] contains 2
    // arr[ high .. n-1 ] contains 3
 
    // termination condition : Evert Iteration unkown length decreases so eventually will be Zero
    while( mid1 <= mid2 )
    {
        switch( arr[ mid1 ])
        {
            case 0 :
            {
                std::swap( arr[ low ] , arr [ mid1 ] );
                low ++ ;
                mid1 ++;
                break;
            }
 
            case 1 :
            {
                mid1 ++;
                break;
            }
 
            case 2 :
            {
                std::swap( arr[ mid1 ] , arr[ mid2 ]);
                mid2 -- ;
                break;
            }
 
            case 3 :
            {
                std::swap( arr[ mid1 ] , arr[ mid2 ]);
                std::swap( arr[ mid2 ] , arr[ high ]);
                mid2 --;
                high --;
                break;
            }
 
        }
    }
 
    for( int i =0 ; i < n ; i++)
    {
        cout << arr[ i ] << " " ;
    }
}
 
int main() 
{
    int arr[] = {1,2,3,0,2,1,3,0,2,1,0,1,3,1,0,2,1,0};
    int n = sizeof(arr) / sizeof(arr[0]) ;
    DutchNationalFlag4(arr , n );
    return 0;
}