Question

我几天都试图这样做，但我所能做的就是对完整列表进行排序，但无法从特定索引中进行排序。

假设我有以下列表，例如

List<byte[]> byteArrayList = new list<byte[]>();
byteArrayList.Add(new byte[]{1, 2, 3, 5, 9, 6, 7, 6, 45, 50, 39 });
byteArrayList.Add(new byte[]{0, 1, 0, 1, 0, 1, 0, 1, 99, 99, 99, 99, 99, 99});
byteArrayList.Add(new byte[]{2, 2, 2, 2, 3, 3, 3, 3 });
byteArrayList.Add(new byte[]{0, 0, 0, 0, 0, 0, 0, 0, 31, 21 });
byteArrayList.Add(new byte[]{1, 22, 32, 22, 3, 3, 3, 3, 12, 13, 14, 15 });
byteArrayList.Add(new byte[]{0, 0, 0, 0, 0, 0, 0, 0, 95, 85, 75});

然后说当前列表索引

ListPoisition = 2;

因此，列表应该从ListPoisition == 2排序到列表的末尾。

结果列表应如下所示：

byteArrayList = {  {1, 2, 3, 5, 9, 6, 7, 6, 45, 50, 39 },
                   {0, 1, 0, 1, 0, 1, 0, 1, 99, 99, 99, 99, 99, 99 },
                   {0, 0, 0, 0, 0, 0, 0, 0, 31, 21 },
                   {0, 0, 0, 0, 0, 0, 0, 0, 95, 85, 75},
                   {1, 22, 32, 22, 3, 3, 3, 3, 12, 13, 14, 15 },
                   {2, 2, 2, 2, 3, 3, 3, 3 }
                };

这只是一个例子。但实际列表可以包含N个byte []。

Answer 1

您可以使用以下扩展方法

public static void PartialSort<T>(this T[] array, int startIndex, int endIndex)  
{  
    T[] sortedList = new T[(endIndex - startIndex) + 1];  

    for (int i = startIndex; i <= endIndex; i++)  
    {  
        sortedList[i - startIndex] = array[i];  
    }  
    List<T> newList = new List<T>(sortedList);  
    newList.Sort();  
    sortedList = newList.ToArray();  

    for (int i = 0; i < sortedList.Length; i++)  
        array[i + startIndex] = sortedList[i];  
}

如果要从位置2对列表中的每个数组进行排序，则可以执行以下操作：

var start = 2;
foreach (var entry in byteArrayList)
{
    entry.PartialSort(start, entry.Length - 1);
}

这是一个有效的demo

如果要从列表中的索引2对每个数组进行排序，则可以执行以下操作：

var ListPosition=2;
for (var index = 0; index < byteArrayList.Count; index++)
{
    if (index >= ListPosition)
        byteArrayList[index].PartialSort(0, byteArrayList[index].Length - 1);
}

这是一个有效的demo

<强>已更新

根据您的评论，您只想对列表进行排序，而不是对内部的数组进行排序，所以您可以在此处执行以下操作：

定义自定义比较器
使用列表的排序方法

比较器类

public class ByteArrayComparer : IComparer<byte[]>
{
    public int Compare(byte[] first, byte[] second)
    {
        // find the minimum length of the both arrays
        var length = first.Length > second.Length ? second.Length : first.Length;
        for (var index = 0; index < length; index++)
        {
             if (first[index] > second[index])
                  return 1;
             if (second[index] > first[index])
                  return -1;
        }
        return 0;
    }
}

您的代码应如下所示

var ListPosition = 2;
if(ListPosition< byteArrayList.Count && ListPosition>-1)
     byteArrayList.Sort(start,byteArrayList.Count - start, new ByteArrayComparer());

这是一个有效的demo

Answer 2

试试这个，

arrayList.Select(x => x.Take(2).Concat(x.Skip(2).OrderBy(y => y)).ToArray()).ToList();

如果我们过去的话;

Select第一个字节数组并取第2个索引。（因为我们会 concat到排序列表）
然后在Concat中，我们skip首先索引并订购它，
在这些之后，前两个索引和已排序的休息符彼此绑定。

（Skip和Take会返回剩余的元素，这就是Concat使用的原因。）

以下是result

希望有所帮助，

Answer 3

这是自定义比较器：

public class CompareByteArrays : IComparer<byte[]>
{
    public int Compare(byte[] a1, byte[] a2)
    {
        int shorterLength = a1.Length < a2.Length ? a1.Length : a2.Length;
        for(int i = 0; i < shorterLength; i++)
        {
            if(a1[i] < a2[i])
            {
                return -1;
            }
            else if(a1[i] > a2[i])
            {
                return 1;
            }
        }
        return a1.Length.CompareTo(a2.Length);
    }
}

然后这是从某个索引中对其进行排序的函数：

public List<byte[]> SortFromIndex(List<byte[]> source, int index)
{
    return source.Take(index).Concat(source.Skip(index).OrderBy(o=>o, new CompareByteArrays())).ToList();
}

所以这就是你在主要方面打电话的方式：

List<byte[]> byteArrayList = new List<byte[]>();
byteArrayList.Add(new byte[] { 1, 2, 3, 5, 9, 6, 7, 6, 45, 50, 39 });
byteArrayList.Add(new byte[] { 0, 1, 0, 1, 0, 1, 0, 1, 99, 99, 99, 99, 99, 99 });
byteArrayList.Add(new byte[] { 2, 2, 2, 2, 3, 3, 3, 3 });
byteArrayList.Add(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 31, 21 });
byteArrayList.Add(new byte[] { 1, 22, 32, 22, 3, 3, 3, 3, 12, 13, 14, 15 });
byteArrayList.Add(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 95, 85, 75 });

List<byte[]> result = SortFromIndex(byteArrayList, 2);

将列表<byte []>从特定listindex排序到c＃中列表的末尾

3 个答案: