在C#中，按数组的最后一个元素对数组进行排序_C#

在C#中，按数组的最后一个元素对数组进行排序

在C#中，按数组的最后一个元素对数组进行排序,c#,C#,如果我有一个二维数组，如下所示，是否可以按最后一个元素对数组进行排序？（最后一个元素表示2,10,1,5）你可以这样做 public static void Sort(string[,] original) { var data=new List<List<string>>(); for (int i = 0; i < original.GetLength(0); i++) {

如果我有一个二维数组，如下所示，是否可以按最后一个元素对数组进行排序？（最后一个元素表示2,10,1,5）

你可以这样做

  public static void Sort(string[,] original)
    {
        var data=new List<List<string>>();
        for (int i = 0; i < original.GetLength(0); i++)
        {
            var m=new List<string>();
            for (int j = 0; j < original.GetLength(1); j++)
            {
               m.Add(original[i,j]) ; 
            }
            data.Add(m);
        }

        var l = data.OrderBy(x => int.Parse(x[2])).ToList();
        for (int i = 0; i < original.GetLength(0); i++)
        {
            for (int j = 0; j < original.GetLength(1); j++)
            {
                original[i, j] = l[i][j];
            }
        }
    }

公共静态无效排序（字符串[，]原始）
{
var data=新列表（）；
for（int i=0；iint.Parse（x[2]））.ToList（）；
for（int i=0；i

您可以这样做

  public static void Sort(string[,] original)
    {
        var data=new List<List<string>>();
        for (int i = 0; i < original.GetLength(0); i++)
        {
            var m=new List<string>();
            for (int j = 0; j < original.GetLength(1); j++)
            {
               m.Add(original[i,j]) ; 
            }
            data.Add(m);
        }

        var l = data.OrderBy(x => int.Parse(x[2])).ToList();
        for (int i = 0; i < original.GetLength(0); i++)
        {
            for (int j = 0; j < original.GetLength(1); j++)
            {
                original[i, j] = l[i][j];
            }
        }
    }

公共静态无效排序（字符串[，]原始）
{
var data=新列表（）；
for（int i=0；iint.Parse（x[2]））.ToList（）；
for（int i=0；i

这是可能的，但正如评论中已经指出的，有更好的方法来设计数据结构。无论如何，如果您想坚持使用数组，一个可能的解决方案（有很多种方法可以进行排序）可能如下所示：

string[,] original = new string[4, 3] 
{ 
    {"apple","price1", "2"}, 
    {"orange","price2", "10"} , 
    {"Pineapple","price5", "1"}, 
    {"Kiwi","price3", "5"}
};
// extract the data
var indexAndOrder = new List<Tuple<string, string, int>>();
for (var i = 0; i < original[0,0].Length - 1; i++)
{
    var current = int.Parse(original[i, 2]);
    indexAndOrder.Add(new Tuple<string, string, int>(original[i,0], original[i,1], current));
}
// anonymous object to sort the indices
var sortedArray = indexAndOrder
                        .Select (ao => new { Name = ao.Item1, Price = ao.Item2, Index = ao.Item3})
                        .ToList()               
                        .OrderBy (ao => ao.Index)
                        //.OrderByDescending (ao => ao.Index)
                        .ToArray();
foreach (var item in sortedArray)
{
    Console.WriteLine(string.Format("{0} - {1} - {2}", item.Index, item.Name, item.Price));
}

算法始终可以在函数中提取并返回新的排序数组。

这是可能的，但正如注释中所指出的，有更好的方法来设计数据结构。无论如何，如果您想坚持使用数组，一个可能的解决方案（有很多种方法可以进行排序）可能如下所示：

string[,] original = new string[4, 3] 
{ 
    {"apple","price1", "2"}, 
    {"orange","price2", "10"} , 
    {"Pineapple","price5", "1"}, 
    {"Kiwi","price3", "5"}
};
// extract the data
var indexAndOrder = new List<Tuple<string, string, int>>();
for (var i = 0; i < original[0,0].Length - 1; i++)
{
    var current = int.Parse(original[i, 2]);
    indexAndOrder.Add(new Tuple<string, string, int>(original[i,0], original[i,1], current));
}
// anonymous object to sort the indices
var sortedArray = indexAndOrder
                        .Select (ao => new { Name = ao.Item1, Price = ao.Item2, Index = ao.Item3})
                        .ToList()               
                        .OrderBy (ao => ao.Index)
                        //.OrderByDescending (ao => ao.Index)
                        .ToArray();
foreach (var item in sortedArray)
{
    Console.WriteLine(string.Format("{0} - {1} - {2}", item.Index, item.Name, item.Price));
}

算法总是可以在函数中提取并返回一个新的排序数组。

这并不能直接回答这个问题，但更干净的实现可能类似于

public class Fruit : IComparer<Fruit>, IComparable<Fruit>
    {
        public Fruit(string name, double price, int quantity)
        {
            Name = name;
            Price = price;
            Quantity = quantity;
        }

        protected int Quantity { get; set; }

        protected double Price { get; set; }

        protected string Name { get; set; }

        public int CompareTo(Fruit other)
        {
            if (Quantity < other.Quantity) return 1;
            if (Quantity > other.Quantity) return -1;
            return 0;
        }

        public override string ToString()
        {
            return string.Format("{0} {1} {2}", Name, Price, Quantity);
        }

        public int Compare(Fruit x, Fruit y)
        {
            if (x.Quantity > y.Quantity) return 1;
            if (x.Quantity < y.Quantity) return -1;
            return 0;
        }
    }

公共类水果：IComparer，IComparable
{
公共水果（字符串名称、双倍价格、整数数量）
{
名称=名称；
价格=价格；
数量=数量；
}
受保护整数数量{get；set；}
受保护双倍价格{get；set；}
受保护的字符串名称{get；set；}
公共国际比较（水果和其他）
{
如果（数量<其他数量）返回1；
如果（数量>其他数量）返回-1；
返回0；
}
公共重写字符串ToString（）
{
返回string.Format（“{0}{1}{2}”，名称、价格、数量）；
}
公共整数比较（水果x、水果y）
{
如果（x数量>y数量）返回1；
如果（x.数量


然后你可以像这样使用新类
var fruits = new List<Fruit>
                {
                    new Fruit("Apple", 0.30, 2),
                    new Fruit("Orange", 0.50, 10),
                    new Fruit("Pineapple", 0.35, 1),
                    new Fruit("Kiwi", 0.33, 5)
                };


            Console.WriteLine("Before sort");
            foreach (var fruit in fruits)
            {
                Console.WriteLine(fruit.ToString());
            }

            fruits.Sort();
            Console.WriteLine("After sort");
            foreach (var fruit in fruits)
            {
                Console.WriteLine(fruit.ToString());
            }

            fruits.Reverse();
            Console.WriteLine("After reverse");
            foreach (var fruit in fruits)
            {
                Console.WriteLine(fruit.ToString());
            }

            Console.ReadLine();

var fruits=新列表
{
新水果（“苹果”，0.30,2），
新水果（“橙色”，0.50,10），
新水果（“菠萝”，0.35,1），
新水果（“猕猴桃”，0.33,5）
};
控制台写入线（“排序前”）；
foreach（水果中的果实）
{
Console.WriteLine（fruit.ToString（））；
}
水果。分类（）；
Console.WriteLine（“排序后”）；
foreach（水果中的果实）
{
Console.WriteLine（fruit.ToString（））；
}
水果。反向（）；
控制台。写线（“反转后”）；
foreach（水果中的果实）
{
Console.WriteLine（fruit.ToString（））；
}
Console.ReadLine（）；

输出：
这并不能直接回答这个问题，但更干净的实现可能类似于
public class Fruit : IComparer<Fruit>, IComparable<Fruit>
    {
        public Fruit(string name, double price, int quantity)
        {
            Name = name;
            Price = price;
            Quantity = quantity;
        }

        protected int Quantity { get; set; }

        protected double Price { get; set; }

        protected string Name { get; set; }

        public int CompareTo(Fruit other)
        {
            if (Quantity < other.Quantity) return 1;
            if (Quantity > other.Quantity) return -1;
            return 0;
        }

        public override string ToString()
        {
            return string.Format("{0} {1} {2}", Name, Price, Quantity);
        }

        public int Compare(Fruit x, Fruit y)
        {
            if (x.Quantity > y.Quantity) return 1;
            if (x.Quantity < y.Quantity) return -1;
            return 0;
        }
    }

公共类水果：IComparer，IComparable
{
公共水果（字符串名称、双倍价格、整数数量）
{
名称=名称；
价格=价格；
数量=数量；
}
受保护整数数量{get；set；}
受保护双倍价格{get；set；}
受保护的字符串名称{get；set；}
公共国际比较（水果和其他）
{
如果（数量<其他数量）返回1；
如果（数量>其他数量）返回-1；
返回0；
}
公共重写字符串ToString（）
{
返回string.Format（“{0}{1}{2}”，名称、价格、数量）；
}
公共整数比较（水果x、水果y）
{
如果（x数量>y数量）返回1；
如果（x.数量

然后你可以像这样使用新类
var fruits = new List<Fruit>
                {
                    new Fruit("Apple", 0.30, 2),
                    new Fruit("Orange", 0.50, 10),
                    new Fruit("Pineapple", 0.35, 1),
                    new Fruit("Kiwi", 0.33, 5)
                };


            Console.WriteLine("Before sort");
            foreach (var fruit in fruits)
            {
                Console.WriteLine(fruit.ToString());
            }

            fruits.Sort();
            Console.WriteLine("After sort");
            foreach (var fruit in fruits)
            {
                Console.WriteLine(fruit.ToString());
            }

            fruits.Reverse();
            Console.WriteLine("After reverse");
            foreach (var fruit in fruits)
            {
                Console.WriteLine(fruit.ToString());
            }

            Console.ReadLine();

var fruits=新列表
{
新水果（“苹果”，0.30,2），
新水果（“橙色”，0.50,10），
新水果（“菠萝”，0.35,1），
新水果（“猕猴桃”，0.33,5）
};
控制台写入线（“排序前”）；
foreach（水果中的果实）
{
Console.WriteLine（fruit.ToString（））；
}
水果。分类（）；
Console.WriteLine（“排序后”）；
foreach（水果中的果实）
{
Console.WriteLine（fruit.ToString（））；
}
水果。反向（）；
控制台。写线（“反转后”）；
foreach（水果中的果实）
{
Console.WriteLine（fruit.ToString（））；
}
Console.ReadL