Question

我有一个数字1和0的列表，只有25的固定大小。

示例：

List<int>() { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

我需要将列表重新排序或排序为：

模式A：

List<int>() { 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1 };

或

模式B：

List<int>() { 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0 };

＆＃34; 1＆＃34;在列表中将始终小于13.列表将循环并搜索最近的＆＃34; 1＆＃34;如果当前指数为＆＃34; 0＆＃34;则用当前指数替换; （或者只从左边或右边开始）。

以下是我的代码片段，用于生成上述两种模式：

List SlotMapLP1 = new List（）{0,1,1,1,1,1,1,1,1,1,0,1,0,1,0,1,0,0,0,0 ，0,0,0,0,0};

int i = 0, j = 0, k = 0, waferCount = 0, loopCtr = 0;
for (i = 0; i < SlotMapLP1.Count; i++ )
{
    if (SlotMapLP1[i] == 1)
        waferCount++;
}

List<int> ptnOne = new List<int>(SlotMapLP1);
List<int> ptnTwo = new List<int>(SlotMapLP1);

j = ptnOne.Count - 1;
while (j >= 0 && loopCtr <= waferCount) //list will start to traverse from right to left
{
    if ((ptnOne[j] == 0 && (j + 1) % 2 > 0))
    {
        k = j - 1;
        while (k >= 0)
        {
            if (ptnOne[k] == 1 && (ptnOne[k] != ptnOne[j]))
            {
                ExtensionMethods.Swap(ptnOne, k, j); //swap the two items
                loopCtr++;
                break;
            }
            k--;
        }
    }
    else
    {
        if (j == 0 || j + 1 == ptnOne.Count) break;
        if (ptnOne[j - 1] == 0 && ptnOne[j + 1] == 1)
        {
            k = j - 1;
            while (k >= 0)
            {
                if (ptnOne[k] == 0 && (ptnOne[k] != ptnOne[j]))
                {
                    ExtensionMethods.Swap(ptnOne, j, k); //swap the two items
                    loopCtr++;
                    break;
                }
                k--;
            }
        }
        else
        {
            k = j - 1;
            while (k >= 0)
            {
                if (ptnOne[k] == 1 && (ptnOne[k] != ptnOne[j]))
                {
                    ExtensionMethods.Swap(ptnOne, j, k); //swap the two items
                    loopCtr++;
                    break;
                }
                k--;
            }
        }
    }
    j--;
}

loopCtr = 0; j = 0; k = 0;
while (j < ptnTwo.Count && loopCtr <= waferCount)//list will start to traverse from left to right
{
    if (ptnTwo[j] == 0 && (j + 1) % 2 > 0)
    {
        k = j + 1;
        while (k < ptnTwo.Count)
        {
            if (ptnTwo[k] == 1 && (ptnTwo[k] != ptnTwo[j]))
            {
                ExtensionMethods.Swap(ptnTwo, j, k); //swap the two items
                loopCtr++;
                break;
            }
            k++;
        }
    }
    else
    {
        if (j == 0 || j + 1 == ptnOne.Count) break;
        if (ptnTwo[j + 1] == 0 && ptnTwo[j - 1] == 1)
        {
            k = j + 1;
            while (k < ptnTwo.Count)
            {
                if (ptnTwo[k] == 0 && (ptnTwo[k] != ptnTwo[j]))
                {
                    ExtensionMethods.Swap(ptnTwo, j, k); //swap the two items
                    loopCtr++;
                    break;
                }
                k++;
            }
        }
        else
        {
            k = j + 1;
            while (k < ptnTwo.Count)
            {
                if (ptnTwo[k] == 1 && (ptnTwo[k] != ptnTwo[j]))
                {
                    ExtensionMethods.Swap(ptnTwo, j, k); //swap the two items
                    loopCtr++;
                    break;
                }
                k++;
            }
        }
    }
    j++;
}

然而，我确实面临一些问题。如果我使用此方法，并非所有列表输入都可以交替排序或重新排序。

是否有更好的方法或方法来执行此类排序？

Answer 1

有一个解决方案并不涉及交换列表中的元素。你只需要找出模式。

如果只有一个1：

1000000000000000000000000

有＆＃34; 1＆＃34;然后是24个零。

如果有2个：

1010000000000000000000000

有＆＃34; 101＆＃34;模式后跟22个零。

看看我在哪里？

对于3个人：

1010100000000000000000000

有＆＃34; 10101＆＃34;模式后跟20个零。

所以你只需计算一些数量并从那里构建你的模式。然后算法变为：

设n =列表中的数目
如果没有，则模式A和B都只有25个零。
否则建立长度为n * 2 - 1的交替模式。
对于模式A，连接25 - （n * 2 - 1）个零和交替模式。
对于模式B，连接交替模式和25 - （n * 2 - 1）个零。（或与模式A相反）

Answer 2

如果大小实际上固定为25个项目，我认为更容易计算1的数量并根据该数量构建新的列表。

Answer 3

我使用模式A和模式B进行测试但是由于需要多次检查，它会使我的代码变长。我创建了新的模式，到目前为止我测试的最适合我需要移动硬件的应用程序。只是为了分享我的想法。

模式C：

List（）{0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1 ，0,1,0};

以下是代码部分：

        List<int> SlotMapLP1 = new List<int>();

        for (int x = 0; x < 25; x++)
        {
            SlotMapLP1.Add(int.Parse(waferArrangement.Substring(x, 1))); //input string contains 1 and 0; where 1 should be max 12 count only
        }

        int i = 0, j = 0, k = 0, waferCount = 0;
        for (i = 0; i < SlotMapLP1.Count; i++ )
            if (SlotMapLP1[i] == 1)
                waferCount++;

        List<int> ptnOne = new List<int>(SlotMapLP1);

        for (j = 0; j < ptnOne.Count; j++ )
        {
            if(j == 0 || j % 2 == 0)
            {
                if (ptnOne[j] == 1)
                {
                    k = j + 1;
                    while (k < ptnOne.Count())
                    {
                        if (ptnOne[k] == 0)
                        {
                            ExtensionMethods.Swap(ptnOne, k, j); //swap position
                            break;
                        }
                        k++;
                    }
                }
            }
            else
            {
                if (ptnOne[j] == 0)
                {
                    k = j + 1;
                    while (k < ptnOne.Count())
                    {

                        if (ptnOne[k] == 1)
                        {
                            ExtensionMethods.Swap(ptnOne, k, j); //swap position
                            break;
                        }
                        k++;
                    }
                }
            }
        }

我测试了几个输入，排序/重新排序功能运行良好。

在C＃中交替排序或重新排序列表

3 个答案: