Wie sortiere ich dieses Array korrekt?

Question

Ich versuche, eine Anordnung von gestapelten Würfeln zu sortieren. Das Array sieht wie folgt aus (ein Beispiel)

Nth Cube | Position (0, its on the desk, >0, its on another cube) 
--- 
1|6 
--- 
2|8 
--- 
3|0 
--- 
4|0 
--- 
5|0 
--- 
6|0 
--- 
7|1 
--- 
8|4 
--- 

die wie folgt

visualisiert aussehen würde

[7] [2] 
--- 
[1] [8] 
--- 
[6] [4] [3] [5] 
--- 

ich die Würfel aussortiert, die auf einer anderen sind:

string [,] In diesem Fall ist das gesamte Array

static string[,] stackedCubes(string[,] t) 
    { 
     string[,] stackedHelp = new string[NumberOfStacked(),2]; 
     int j = 0; 
     for (int i = 0; i < t.GetLength(0); i++) 
     { 
      if (t[i, 1]!="0") 
      { 

       stackedHelp[j, 0] = t[i, 0]; 
       stackedHelp[j, 1] = t[i, 1]; 
       j++; 
      } 
     } 
     return stackedHelp; 
    } 

, die kommt als:

1|6 
--- 
2|8 
--- 
7|1 
--- 
8|4 
--- 

jetzt im sie versuchen, von oben zu legen (so 7/2 dann 1/8)

string [,] t ab hier ist stackedCubes

static string[,] Putdown(string[,] t) 
    { 
     string[,] stackedOrder = new string[NumberOfStacked(), 2]; 
     int j = 0; 
     do 
     { 
      for (int i = 0; i < t.GetLength(0); i++) 
      { 
       if (t[i, 1] == t[j, 0]) 
       { 
        j = i; 
       } 
       else if(IsSomethingOnTheCube(t[j,0],t)==false) 
       { 
        stackedOrder[i, 0] = t[j, 0]; 
        stackedOrder[i, 1] = "0"; 
        t[i, 1] = "0"; 
       } 
      } 
     } 
     while (AreAllTheCubesOnTable(t) != true); 

     return stackedOrder; 
    } 

hier im vom ersten Cube 1 (t [j, 0]) gehen und überprüfen, ob es etwas ist, es es auf t findet [i, 1] und gibt die 7 (t [zurück j, 0]) und geht zurück. ich überprüfen, ob es etwas auf dem Cube ist hier

static bool IsSomethingOnTheCube(string Cube,string[,] t) 
    { 
     for (int i = 0; i < t.GetLength(0); i++) 
     { 
      if(Cube==t[i,1]) 
      { 
       return true; 
      } 
     } 
     return false; 
    } 

ich auch, ob oder nicht, sind sie alle auf dem Schreibtisch (mit dem do-while)

static bool AreAllTheCubesOnTable(string[,] t) 
    { 
     for (int i = 0; i < t.GetLength(0); i++) 
     { 
      if (t[i, 1] != "0") 
      { 
       return false; 
      } 
     } 
     return true; 
    } 

Und der Ausgang ist alles falsch :

7|0 
--- 
7|0 
--- 
7|0 
--- 
7|0 
--- 

, wenn es so etwas wie sein sollte:

7|0 
--- 
1|0 
--- 
2|0 
--- 
8|0 
--- 

Wo bin ich falsch Indizierung? (Oder etwas anderes)

Answer 1

In der Probe bereitgestellt

string[] cubes = new string[] 
    {"1|6", "2|8", "3|0", "4|0", "5|0", "6|0", "7|1", "8|4"}; 

Unterm Strich in der Frage sieht aus wie zufällig ein. Lassen Sie uns die niedrigsten Würfel bestellen (sagen wir, lexikographisch) und so wird die Visualisierung sein:

lines: 
    2:  [2]  [7] 
    1:  [8]  [1] 
    0: [3] [4] [5] [6] <- bottom line is sorted 
------------------------ 
files: 0 1 2 3 

dies getan haben, können wir zwei Hilfe Methoden implementieren:

// Line: 0 for lowest cubes 
    private static int CubeLine(string value, IEnumerable<String> stack) { 
     for (int line = 0; ; ++line) { 
     string parent = value.Substring(value.IndexOf('|') + 1); 

     if ("0".Equals(parent)) 
      return line; 

     value = stack.First(item => item.StartsWith(parent + "|")); 
     } 
    } 

Und

// File: 0 for leftmost cubes 
    private static int CubeFile(string value, IEnumerable<String> stack) { 
     string root = value; 

     while (true) { 
     string parent = root.Substring(root.IndexOf('|') + 1); 

     if ("0".Equals(parent)) 
      break; 

     root = stack.First(item => item.StartsWith(parent + "|")); 
     } 

     return stack 
     .Where(item => item.Substring(value.IndexOf('|') + 1) == "0") 
     .OrderBy(item => item) 
     .Select((item, index) => new { 
      item = item, 
      index = index 
     }) 
     .First(item => item.item == root) 
     .index; 
    } 

Und dann können Sie leicht sortieren, was auch immer Sie mögen.Zum Beispiel lassen Sie uns zuerst oberste Würfel sortieren, bei tie ganz links zuerst:

string[] cubes = new string[] 
    {"1|6", "2|8", "3|0", "4|0", "5|0", "6|0", "7|1", "8|4"}; 

    var result = cubes 
    .Select (cube => new { 
     name = cube.Substring(0, cube.IndexOf('|')), 
     file = CubeFile(cube, cubes), 
     line = CubeLine(cube, cubes) }) 
    .OrderByDescending(cube => cube.line) 
    .ThenBy(cube => cube.file) 
    .Select(cube => cube.name); 

    Console.Write(string.Join(", ", result)); 

Outcome

2, 7, 8, 1, 3, 4, 5, 6 

bearbeiten ist: Wenn Sie nach rechts zuerst von oben nach unten sortieren links wollen auf Bindung:

var result = cubes 
    .Select (cube => new { 
     name = cube.Substring(0, cube.IndexOf('|')), 
     file = CubeFile(cube, cubes), 
     line = CubeLine(cube, cubes) }) 
    .OrderBy(cube => cube.file) 
    .ThenByDescending(cube => cube.line) 
    .Select(cube => cube.name); 

Und das Ergebnis ist

Edit 2: Legte Reihenfolge: der Boden zuerst, Bindungen willkürlich

var result = cubes 
    .Select (cube => new { 
     name = cube.Substring(0, cube.IndexOf('|')), 
     file = CubeFile(cube, cubes), 
     line = CubeLine(cube, cubes) }) 
    .OrderBy(cube => cube.line) 
    .Select(cube => cube.name); 

Ergebnis:

3, 4, 5, 6, 1, 8, 2, 7 

Answer 2

Obwohl mehrdimensionalen Arrays in zahlreichen Beispielen verwendet werden, wenn das Programm starten, eine Anordnung unter Verwendung von von stark typisierten Klassen ist generell zu empfehlen. Das heißt, wenn das mehrdimensionale Array immer noch in ein anderes Format wie ein Wörterbuch geparst werden kann. Zum Beispiel:

string[,] cubes = {{"1","6"} ,{ "2","8"} ,{ "3","0"} ,{ "4","0"} ,{ "5","0"} ,{ "6","0"} ,{ "7","1"} ,{ "8","4"}}; 


//create a dictionary of all cube-parents 
var parents = (from i in Enumerable.Range(0, cubes.GetLength(0))      
       group cubes[i,0] by cubes[i,1]) 
       .ToDictionary(g=>g.Key, g=>g.ToArray());  

var layer = parents["0"]; //table level cubes [3,4,5,6] 
var layers= new List<string[]>(); 
while(layer != null){ 
    layers.Add(layer); 
    string[] children, nextlayer = null; 
    for(int i = 0; i < layer.Length; i++) 
     if(layer[i] != null && parents.TryGetValue(layer[i], out children)){ 
      if(nextlayer==null)nextlayer= new string[layer.Length]; 
      nextlayer[i] = children[0]; //what to do with multiple children? 
     } 
    layer= nextlayer; 
}; 

Wenn die oben abgeschlossen ist, enthält layers{[3,4,5,6],[null,8,null,1], [null,2,null,7]} Mit anderen Worten: die mehreren Schichten. Ich bin mir nicht ganz sicher, welches das gewünschte Endergebnis ist. Ist es die visuelle Darstellung oder etwas wie alle Würfel nicht auf dem Tisch (für letzteres wären es einfach alle Elemente, die kein Eltern '0' haben)