c# - 如何对填充有随机数的二维数组进行排序

Question

我正在做一个班级作业，
我需要创建一个随机数的二维数组并将它们排序为气泡或其他排序代码。我对单个数组很好，但问题是一个充满随机数的二维数组，我就是不明白。随机数应由 (-I,I) 间隔组成，它是用户输入。抱歉英语不好，没有获得任何学位。在处理可视化 C# windows 窗体时。寻找简单的情侣cicles方法。例子。：A[MxN] ->>> B[MxN] (Sorted 1.....n)

Answer 1

这是一个解决方案，它首先将每一行的列按顺序排序，然后按第一列比较每一行，然后是第二列，依此类推：

namespace StackOverflow.Demos
{

    class Program
    {

        public static void Main(string[] args) 
        {
            new Program();
            Console.WriteLine("Done");
            Console.ReadKey();
        }
        Program()
        {
            double[,] data = GenerateData();
            OutputData(data, "Before");
            SortData(ref data);
            OutputData(data, "After");
        }
        double[,] GenerateData()
        {
            Random randomGenerator = new Random(DateTime.UtcNow.Millisecond);
            double[,] data = new double[5, 5];
            for (int i = 0; i < data.GetLength(0); i++)
            {
                for (int j = 0; j < data.GetLength(1); j++)
                {
                    data[i, j] = (randomGenerator.NextDouble() * 2) - 1;
                }
            }
            return data;
        }
        void OutputData(double[,] data, string message)
        {
            Console.WriteLine("=====================");
            Console.WriteLine(message);
            Console.WriteLine("=====================");
            for (int i = 0; i < data.GetLength(0); i++)
            {
                for (int j = 0; j < data.GetLength(1); j++)
                {
                    Console.Write(data[i, j]);
                    Console.Write("\t");
                }
                Console.WriteLine();
            }
        }
        void SortData(ref double[,] data)
        {
            //sort sub arrays
            SortDataRows(ref data);
            //sort this array
            for (int i = 0; i < data.GetLength(0)-1; i++)
            {
                for (int j = i; j < data.GetLength(0); j++)
                {
                    for (int k = 0; k < data.GetLength(1); k++)
                    {
                        if (data[i, k].CompareTo(data[j, k]) < 0) //if already in order exit loop
                        {
                            break;
                        } else if (data[i, k].CompareTo(data[j, k]) > 0) //if out of order switch and loop
                        {
                            SwapRows(ref data, i, j);
                            break;
                        }//else orders are equal so far; continue to loop
                    }
                }
            }
        }
        void SortDataRows(ref double[,] data)
        {
            for (int row = 0; row < data.GetLength(0); row++)
            {
                for (int i = 0; i < data.GetLength(1) - 1; i++)
                {
                    for (int j = i; j < data.GetLength(1); j++)
                    {
                        if (data[row, i].CompareTo(data[row, j]) > 0)
                        {
                            Swap<double>(ref data[row, i], ref data[row, j]);
                        }
                    }
                }
            }
        }
        void Swap<T>(ref T a, ref T b)
        {
            T temp = a;
            a = b;
            b = temp;
        }
        void SwapRows(ref double[,]data, int i, int j)
        {
            for (int k = 0; k < data.GetLength(1); k++)
            {
                Swap<double>(ref data[i, k], ref data[j, k]);
            }
        }
    }

}

代码不是最好的（还没有喝杯茶），但应该做你所追求的。

这是一个更好的解决方案（不使用二维数组，而是使用可以轻松转换为/从此类数组转换的结构）：

唱 System.Diagnostics；

namespace StackOverflow.Demos
{

    class Program
    {

        public static void Main(string[] args) 
        {
            new Program();
            Console.WriteLine("Done");
            Console.ReadKey();
        }
        Program()
        {
            List<List<double>> data = GenerateData(5, 5).ToList<List<double>>();
            OutputData(data,"Before");
            foreach (List<double> item in data)
            {
                item.Sort();
            }
            data.Sort(CompareListOfDoubles);
            OutputData(data,"After");
        }

        private IEnumerable<List<double>> GenerateData(int index1, int index2)
        {
            Random rnd = new Random(DateTime.UtcNow.Millisecond);
            List<double> result;
            for (int i = 0; i < index1; i++)
            {
                result = new List<double>(index2);
                for (int j = 0; j < index2; j++)
                {
                    result.Add(rnd.NextDouble() * 2 - 1);
                }
                yield return result;
            }
        }
        private void OutputData(List<List<double>> data, string message)
        {
            Console.WriteLine(message);
            foreach (List<double> list in data)
            {
                foreach (double datum in list)
                {
                    Console.Write(datum);
                    Console.Write("\t");
                }
                Console.WriteLine();
            }
        }
        static int CompareListOfDoubles(List<double> a, List<double> b)
        {
            for (int i = 0; i < a.Count; i++)
            {
                if (i > b.Count) return -1;
                if (a[i] > b[i]) return -1;
                if (a[i] < b[i]) return 1;
            }
            if (b.Count > a.Count) return 1;
            return 0;
        }
        double[,] ConvertListListDoubleTo2DArray(List<List<double>> data)
        {
            double[,] result = new double[data.Count, data[0].Count];
            for (int i = 0; i < result.GetLength(0); i++)
            {
                for (int j = 0; j < result.GetLength(1); j++)
                {
                    result[i, j] = data[i][j];
                }
            }
            return result;
        }
    }

Answer 2

获取随机数很简单：

Random rnd;

for (int y = 0; y < h; y++)
    for (int x = 0; x < w; x++)
        array[y][x] = l - rnd.Next(2 * l + 1);

Random.Next()将返回 0 和给定参数之间的随机值（不包括参数；这是 的原因+ 1）。

2D 数组可以像 1D 数组一样排序，它只取决于您要如何处理多行，例如它只是为了显示还是您想为自己排序每一行等。