我有一个只有固定大小为 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 个零。
如果有2个:
1010000000000000000000000
有一个“101”模式后跟 22 个零。
看到我要说的了吗?
对于 3 个:
1010100000000000000000000
有一个“10101”模式后跟 20 个零。
因此,您只需计算 1 的数量并从那里构建您的模式。然后算法变成:
- 让 n = 列表中的个数
- 如果没有,则模式 A 和 B 都只有 25 个零。
- 否则构建长度为 n * 2 - 1 的交替模式。
- 对于模式 A,连接 25 - (n * 2 - 1) 个零和交替模式。
- 对于模式 B,连接交替模式和 25 - (n * 2 - 1) 个零。 (或模式 A 的反面)
关于c# - 在 C# 中交替排序或重新排序列表,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/33361872/