如何對用隨機數填充的二維數組進行排序

Question

我正在做一個類的分配，
我需要創建一個隨機數的二維數組，並將它們排序爲氣泡或其他排序代碼。我對單個數組很好，但問題是填充了隨機數的二維數組，我只是不明白。 隨機數字應該是（-I，I）間隔它是用戶輸入。對不起英文不好，還沒有獲得任何學位。在Visual C＃窗體上工作。 尋找簡單的夫妻方法。例如 。 ：A[MxN] ->>> B[MxN] (Sorted 1.....n)

Answer 1

獲取的隨機數是微不足道：

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的原因）。

二維數組可以像一維數組一樣排序，它只取決於您想要如何處理多行，它只是用於顯示或做你想做的每一行自行解決，等

Answer 2

這裏有一個解決方案，首先會在每個行的列插入順序，然後排序每行由第一列比較，然後第二等：

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]); 
      } 
     } 
    } 

} 

該代碼不是最好的（還沒有喝杯茶），但應該做你以後的事情。

這裏的一個更好的解決方案（不使用2D陣列本身，而是使用可以很容易地從這樣的陣列轉換成/結構）：

唱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; 
     } 
    }