C# 对不同长度的二维数组进行排序_C#_.net_Algorithm_Sorting

C# 对不同长度的二维数组进行排序

c# .net algorithm sorting

C# 对不同长度的二维数组进行排序,c#,.net,algorithm,sorting,C#,.net,Algorithm,Sorting,各位程序员我正在尝试对二维数组进行排序。此数组表示一组对象，这些对象的属性在下面的列表中有一个值。因此，不必保存原始列表开始的情况是： var list = new List<string> { "10-158-6", "11-158-6", "90-158-6", "20-15438-6", "10-158-6", "1

各位程序员

我正在尝试对二维数组进行排序。此数组表示一组对象，这些对象的属性在下面的列表中有一个值。因此，不必保存原始列表

开始的情况是：

var list = new List<string>
        {
            "10-158-6",
            "11-158-6",
            "90-158-6",
            "20-15438-6",
            "10-158-6",
            "10-158-6-3434",
            "10-1528-6"
        };

var list=新列表
{
"10-158-6",
"11-158-6",
"90-158-6",
"20-15438-6",
"10-158-6",
"10-158-6-3434",
"10-1528-6"
};

结果应该是

var list = new List<string>
            {
                "10-158-6",
                "10-158-6",
                "10-1528-6"
                "10-158-6-3434",
                "11-158-6",
                "20-15438-6",
                "90-158-6",
            };

var list=新列表
{
"10-158-6",
"10-158-6",
"10-1528-6"
"10-158-6-3434",
"11-158-6",
"20-15438-6",
"90-158-6",
};

应该先在第一个零件上订购->然后在第二个零件上->等等

我认为对这些字符串进行排序几乎是不可能的，所以我将其转换为二维列表。我找到了不同的解决方案来对多维列表进行排序，但没有一种方法可以解决这个问题。我也不知道从哪里开始

有人知道如何编写一个排序算法，而不必有不必要的大O

提前谢谢

Jeroen

您可以使用

排序方法；让我们实现一个任意长数字的一般情况：
代码：
  var list = new List<string>() {
    "10-158-6",
    "11-158-6",
    "90-158-6",
    "20-15438-6",
    "10-158-6",
    "10-158-6-3434",
    "10-1528-6",
    "123456789012345678901234567890"
  };

  list.Sort((left, right) => {
    var x = left.Split('-');
    var y = right.Split('-');

    // Compare numbers:
    for (int i = 0; i < Math.Min(x.Length, y.Length); ++i) {
      // Longer number is always bigger: "123" > "99"
      int r = x[i].Length.CompareTo(y[i].Length);

      // If numbers are of the same length, compare lexicographically: "459" < "460"
      if (r == 0)
        r = string.CompareOrdinal(x[i], y[i]);

      if (r != 0)
        return r;
    }

    // finally, the more items the bigger: "123-456-789" >  "123-456"
    return x.Length.CompareTo(y.Length);
  });

  // Let's have a look at the list after the sorting
  Console.Write(string.Join(Environment.NewLine, list));

10-158-6
10-158-6
10-158-6-3434  // <- please, note that since 158 < 1528
10-1528-6      // <- "10-158-6-3434" is before "10-1528-6" 
11-158-6
20-15438-6
90-158-6
123456789012345678901234567890

var list=新列表（）{
"10-158-6",
"11-158-6",
"90-158-6",
"20-15438-6",
"10-158-6",
"10-158-6-3434",
"10-1528-6",
"123456789012345678901234567890"
};
list.Sort（（左、右）=>{
var x=左。拆分（'-'）；
变量y=右。拆分（'-'）；
//比较数字：
对于（int i=0；i“99”
int r=x[i].Length.CompareTo（y[i].Length）；
//如果数字长度相同，请按字典顺序进行比较：“459”<“460”
如果（r==0）
r=string.CompareOrdinal（x[i]，y[i]）；
如果（r！=0）
返回r；
}
//最后，项目越多越大：“123-456-789”>“123-456”
返回x.Length.CompareTo（y.Length）；
});
//我们来看看排序后的列表
Write（string.Join（Environment.NewLine，list））；

结果：
  var list = new List<string>() {
    "10-158-6",
    "11-158-6",
    "90-158-6",
    "20-15438-6",
    "10-158-6",
    "10-158-6-3434",
    "10-1528-6",
    "123456789012345678901234567890"
  };

  list.Sort((left, right) => {
    var x = left.Split('-');
    var y = right.Split('-');

    // Compare numbers:
    for (int i = 0; i < Math.Min(x.Length, y.Length); ++i) {
      // Longer number is always bigger: "123" > "99"
      int r = x[i].Length.CompareTo(y[i].Length);

      // If numbers are of the same length, compare lexicographically: "459" < "460"
      if (r == 0)
        r = string.CompareOrdinal(x[i], y[i]);

      if (r != 0)
        return r;
    }

    // finally, the more items the bigger: "123-456-789" >  "123-456"
    return x.Length.CompareTo(y.Length);
  });

  // Let's have a look at the list after the sorting
  Console.Write(string.Join(Environment.NewLine, list));

10-158-6
10-158-6
10-158-6-3434  // <- please, note that since 158 < 1528
10-1528-6      // <- "10-158-6-3434" is before "10-1528-6" 
11-158-6
20-15438-6
90-158-6
123456789012345678901234567890

10-158-6
10-158-6
10-158-6-3434/您可以使用Sort
方法；让我们实现一个任意长数字的一般情况：
代码：
  var list = new List<string>() {
    "10-158-6",
    "11-158-6",
    "90-158-6",
    "20-15438-6",
    "10-158-6",
    "10-158-6-3434",
    "10-1528-6",
    "123456789012345678901234567890"
  };

  list.Sort((left, right) => {
    var x = left.Split('-');
    var y = right.Split('-');

    // Compare numbers:
    for (int i = 0; i < Math.Min(x.Length, y.Length); ++i) {
      // Longer number is always bigger: "123" > "99"
      int r = x[i].Length.CompareTo(y[i].Length);

      // If numbers are of the same length, compare lexicographically: "459" < "460"
      if (r == 0)
        r = string.CompareOrdinal(x[i], y[i]);

      if (r != 0)
        return r;
    }

    // finally, the more items the bigger: "123-456-789" >  "123-456"
    return x.Length.CompareTo(y.Length);
  });

  // Let's have a look at the list after the sorting
  Console.Write(string.Join(Environment.NewLine, list));

10-158-6
10-158-6
10-158-6-3434  // <- please, note that since 158 < 1528
10-1528-6      // <- "10-158-6-3434" is before "10-1528-6" 
11-158-6
20-15438-6
90-158-6
123456789012345678901234567890

var list=新列表（）{
"10-158-6",
"11-158-6",
"90-158-6",
"20-15438-6",
"10-158-6",
"10-158-6-3434",
"10-1528-6",
"123456789012345678901234567890"
};
list.Sort（（左、右）=>{
var x=左。拆分（'-'）；
变量y=右。拆分（'-'）；
//比较数字：
对于（int i=0；i“99”
int r=x[i].Length.CompareTo（y[i].Length）；
//如果数字长度相同，请按字典顺序进行比较：“459”<“460”
如果（r==0）
r=string.CompareOrdinal（x[i]，y[i]）；
如果（r！=0）
返回r；
}
//最后，项目越多越大：“123-456-789”>“123-456”
返回x.Length.CompareTo（y.Length）；
});
//我们来看看排序后的列表
Write（string.Join（Environment.NewLine，list））；

结果：
  var list = new List<string>() {
    "10-158-6",
    "11-158-6",
    "90-158-6",
    "20-15438-6",
    "10-158-6",
    "10-158-6-3434",
    "10-1528-6",
    "123456789012345678901234567890"
  };

  list.Sort((left, right) => {
    var x = left.Split('-');
    var y = right.Split('-');

    // Compare numbers:
    for (int i = 0; i < Math.Min(x.Length, y.Length); ++i) {
      // Longer number is always bigger: "123" > "99"
      int r = x[i].Length.CompareTo(y[i].Length);

      // If numbers are of the same length, compare lexicographically: "459" < "460"
      if (r == 0)
        r = string.CompareOrdinal(x[i], y[i]);

      if (r != 0)
        return r;
    }

    // finally, the more items the bigger: "123-456-789" >  "123-456"
    return x.Length.CompareTo(y.Length);
  });

  // Let's have a look at the list after the sorting
  Console.Write(string.Join(Environment.NewLine, list));

10-158-6
10-158-6
10-158-6-3434  // <- please, note that since 158 < 1528
10-1528-6      // <- "10-158-6-3434" is before "10-1528-6" 
11-158-6
20-15438-6
90-158-6
123456789012345678901234567890

10-158-6
10-158-6
10-158-6-3434/那些看起来像版本号。如果从破折号到圆点的变化不是很大的变化，你可以简单地使用C#
var list=新列表
{
"10-158-6",
"11-158-6",
"90-158-6",
"20-15438-6",
"10-158-6",
"10-158-6-3434",
"10-1528-6"
};
var versions=list.Select（x=>newversion（x.Replace（'-'，'.'））.ToList（）；
versions.Sort（）；

这些看起来像版本号。如果从破折号到圆点的变化不是很大的变化，你可以简单地使用C#
var list=新列表
{
"10-158-6",
"11-158-6",
"90-158-6",
"20-15438-6",
"10-158-6",
"10-158-6-3434",
"10-1528-6"
};
var versions=list.Select（x=>newversion（x.Replace（'-'，'.'））.ToList（）；
versions.Sort（）；

词典顺序有什么不同？你试过直接对字符串排序吗？杰普，这是我第一次尝试的。除数字以外的其他字符总是在数字之前排序。所以10-1528在10-158之前-排序时，它应该是另一种方式，为什么你要写，不可能对这个问题的多维列表进行排序？你能展示你尝试过的吗？使用版本就可以了var versions=list.Select（x=>newversion（x.Replace（'-'，'.'））.ToList（）；versions.Sort（）这样就可以了，还是从破折号切换到圆点是不可能的。字典顺序有什么区别？你试过直接对字符串排序吗？杰普，这是我第一次尝试的。除数字以外的其他字符总是在数字之前排序。所以10-1528在10-158之前-排序时，它应该是另一种方式，为什么你要写，不可能对这个问题的多维列表进行排序？你能展示你尝试过的吗？使用版本就可以了var versions=list.Select（x=>newversion（x.Replace（'-'，'.'））.ToList（）；versions.Sort（）这样做会不会奏效，或者从破折号切换到圆点是不可能的。不，这是@Dmitry做对了！非常感谢你！不，这是@Dmitry，没错！非常感谢你！