在C#中交替对列表进行排序或重新排序

贾米勒哈基姆

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

例子:

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 };

列表中“ 1”的最大数目将始终小于13。列表将循环并搜索最接近的“ 1”,如果当前索引为“ 0”(仅从左或右开始),则将其替换为当前索引。

这是我的代码片段,可产生以上两种模式:

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++;
}

但是,我确实遇到了一些问题。如果使用此方法,则不是所有列表输入都可以排序或重新排序。

有没有更好的方法或方法来执行这种类型的排序?

螺旋四方

有一种解决方案不涉及交换列表中的元素。您只需要弄清楚模式即可。

如果只有一个1:

1000000000000000000000000

有一个“ 1”,后跟24个零。

如果有两个:

1010000000000000000000000

有一个“ 101”模式,后跟22个零。

看到我要去哪里?

3个:

1010100000000000000000000

有一个“ 10101”模式,后跟20个零。

因此,您只需要计算一个数并从那里建立模式即可。该算法将变为:

  1. 令n =列表中的个数
  2. 如果没有,则模式A和B都只有25个零。
  3. 其他建立长度为n * 2-1的交替模式。
  4. 对于模式A,将25-(n * 2-1)个零和交替的模式连接起来。
  5. 对于模式B,请连接交替模式和25-(n * 2-1)零。(或图案A的反面)

本文收集自互联网,转载请注明来源。

如有侵权,请联系 [email protected] 删除。

编辑于
0

我来说两句

0 条评论
登录 后参与评论

相关文章