Wie Sortiere ich ein zwei-dimensional (eckig) - array in C#?

Kann ich überprüfen, - meinst du ein rechteckiges array ([,])oder ein verzweigtes array ([][])?

Es ist ganz einfach zu Sortieren, ein verzweigtes array; ich habe eine Diskussion auf, die hier. Offensichtlich sind in diesem Fall die Comparison<T> würde eine Spalte statt der Sortierung nach Ordnungszahl - aber sehr ähnlich.

Sortierung ein rechteckiges array ist etwas schwieriger zu beantworten... ich würde wohl versucht sein, Sie zu kopieren Sie die Daten entweder in einem rechteckigen array oder eine List<T[]> und Sortieren es, dann zurück kopieren.

Hier ist ein Beispiel mit einem jagged array:

static void Main()
{  //could just as easily be string...
    int[][] data = new int[][] { 
        new int[] {1,2,3}, 
        new int[] {2,3,4}, 
        new int[] {2,4,1} 
    }; 
    Sort<int>(data, 2); 
} 
private static void Sort<T>(T[][] data, int col) 
{ 
    Comparer<T> comparer = Comparer<T>.Default;
    Array.Sort<T[]>(data, (x,y) => comparer.Compare(x[col],y[col])); 
} 

Für die Arbeit mit einem rechteckigen array... nun, hier ist etwas code, um ein Umschalten zwischen den beiden auf der fly...

static T[][] ToJagged<T>(this T[,] array) {
    int height = array.GetLength(0), width = array.GetLength(1);
    T[][] jagged = new T[height][];

    for (int i = 0; i < height; i++)
    {
        T[] row = new T[width];
        for (int j = 0; j < width; j++)
        {
            row[j] = array[i, j];
        }
        jagged[i] = row;
    }
    return jagged;
}
static T[,] ToRectangular<T>(this T[][] array)
{
    int height = array.Length, width = array[0].Length;
    T[,] rect = new T[height, width];
    for (int i = 0; i < height; i++)
    {
        T[] row = array[i];
        for (int j = 0; j < width; j++)
        {
            rect[i, j] = row[j];
        }
    }
    return rect;
}
//fill an existing rectangular array from a jagged array
static void WriteRows<T>(this T[,] array, params T[][] rows)
{
    for (int i = 0; i < rows.Length; i++)
    {
        T[] row = rows[i];
        for (int j = 0; j < row.Length; j++)
        {
            array[i, j] = row[j];
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            int[,] arr = { { 20, 9, 11 }, { 30, 5, 6 } };
            Console.WriteLine("before");
            for (int i = 0; i < arr.GetLength(0); i++)
            {
                for (int j = 0; j < arr.GetLength(1); j++)
                {
                    Console.Write("{0,3}", arr[i, j]);
                }
                Console.WriteLine();
            }
            Console.WriteLine("After");

            for (int i = 0; i < arr.GetLength(0); i++) //Array Sorting
            {
                for (int j = arr.GetLength(1) - 1; j > 0; j--)
                {

                    for (int k = 0; k < j; k++)
                    {
                        if (arr[i, k] > arr[i, k + 1])
                        {
                            int temp = arr[i, k];
                            arr[i, k] = arr[i, k + 1];
                            arr[i, k + 1] = temp;
                        }
                    }
                }
                Console.WriteLine();
            }

            for (int i = 0; i < arr.GetLength(0); i++)
            {
                for (int j = 0; j < arr.GetLength(1); j++)
                {
                    Console.Write("{0,3}", arr[i, j]);
                }
                Console.WriteLine();
            }
        }
    }
}

Kann allso schauen Array.Sort-Methode http://msdn.microsoft.com/en-us/library/aa311213(v=vs. 71).aspx

z.B. Array.Sortieren(array, delegate(object[] x, object[] y){ return (x[ i ] as IComparable).CompareTo(y[ i ]);});

vom http://channel9.msdn.com/forums/Coffeehouse/189171-Sorting-Two-Dimensional-Arrays-in-C/

Ausprobieren. Die grundlegende Strategie ist, um die Sortierung der bestimmten Spalte unabhängig und erinnere mich an die ursprüngliche Zeile des Eintrags. Der rest des Codes wird der Zyklus durch die sortierte Spalte Daten und tauschen Sie die Zeilen in das array. Der schwierige Teil ist remembing zu aktualisieren, die ursprüngliche Spalte als swap-Anteil wird effektiv verändern der ursprünglichen Spalte.

        public class Pair<T> {
            public int Index;
            public T Value;
            public Pair(int i, T v) {
                Index = i;
                Value = v;
            }
        }
        static IEnumerable<Pair<T>> Iterate<T>(this IEnumerable<T> source) {
            int index = 0;
            foreach ( var cur in source) {
                yield return new Pair<T>(index,cur);
                index++;
            }
        }
        static void Sort2d(string[][] source, IComparer comp, int col) {
            var colValues = source.Iterate()
                .Select(x => new Pair<string>(x.Index,source[x.Index][col])).ToList();
            colValues.Sort((l,r) => comp.Compare(l.Value, r.Value));
            var temp = new string[source[0].Length];
            var rest = colValues.Iterate();
            while ( rest.Any() ) {
                var pair = rest.First();
                var cur = pair.Value;
                var i = pair.Index;
                if (i == cur.Index ) {
                    rest = rest.Skip(1);
                    continue;
                }

                Array.Copy(source[i], temp, temp.Length);
                Array.Copy(source[cur.Index], source[i], temp.Length);
                Array.Copy(temp, source[cur.Index], temp.Length);
                rest = rest.Skip(1);
                rest.Where(x => x.Value.Index == i).First().Value.Index = cur.Index;
            }
        }

        public static void Test1() {
            var source = new string[][] 
            {
                new string[]{ "foo", "bar", "4" },
                new string[] { "jack", "dog", "1" },
                new string[]{ "boy", "ball", "2" },
                new string[]{ "yellow", "green", "3" }
            };
            Sort2d(source, StringComparer.Ordinal, 2);
        }

Dies ist eine alte Frage, aber hier eine Klasse, die ich gerade gebaut basierend auf der Artikel von Jim Mischel mit ein bei InformIt verbunden durch Doug L.

class Array2DSort : IComparer<int>
{
    //maintain a reference to the 2-dimensional array being sorted
    string[,] _sortArray;
    int[] _tagArray;
    int _sortIndex;

    protected string[,] SortArray { get { return _sortArray; } }

    //constructor initializes the sortArray reference
    public Array2DSort(string[,] theArray, int sortIndex)
    {
        _sortArray = theArray;
        _tagArray = new int[_sortArray.GetLength(0)];
        for (int i = 0; i < _sortArray.GetLength(0); ++i) _tagArray[i] = i;
        _sortIndex = sortIndex;
    }

    public string[,] ToSortedArray()
    {
        Array.Sort(_tagArray, this);
        string[,] result = new string[
            _sortArray.GetLength(0), _sortArray.GetLength(1)];
        for (int i = 0; i < _sortArray.GetLength(0); i++)
        {
            for (int j = 0; j < _sortArray.GetLength(1); j++)
            {
                result[i, j] = _sortArray[_tagArray[i], j];
            }
        }
        return result;
    }

    //x and y are integer row numbers into the sortArray
    public virtual int Compare(int x, int y)
    {
        if (_sortIndex < 0) return 0;
        return CompareStrings(x, y, _sortIndex);
    }

    protected int CompareStrings(int x, int y, int col)
    {
        return _sortArray[x, col].CompareTo(_sortArray[y, col]);
    }
}

Gegeben eine unsortierte 2D-array data beliebiger Größe, die Sie möchten, zu Sortieren, die Spalte 5, die Sie nur dazu:

        Array2DSort comparer = new Array2DSort(data, 5);
        string[,] sortedData = comparer.ToSortedArray();

Hinweis: der virtuelle Compare Methode und geschützt SortArray so dass Sie erstellen können spezialisierte Unterklassen, die immer irgendwie auf eine bestimmte Spalte oder tun spezielle Sortierung über mehrere Spalten oder was auch immer Sie tun möchten. Das ist auch der Grund, warum CompareStrings ist ausgebrochen und geschützt - jede Unterklassen können es verwenden, für einfache Vergleiche, anstatt aus dem vollen SortArray[x, col].CompareTo(SortArray[y, col]) syntax.

Ich weiß, das ist spät, aber hier ist mein Gedanke, Sie würde vielleicht überlegen.

ist dies beispielsweise für die array

{
m,m,m
a,a,a
b,b,b
j,j,j
k,l,m
}

sowie Sie wollen, es zu konvertieren, von Spalte Nummer 2, dann

string[] newArr = new string[arr.length]
for(int a=0;a<arr.length;a++)
newArr[a] = arr[a][1] + a;
//create new array that contains index number at the end and also the coloumn values
Array.Sort(newArr);
for(int a=0;a<newArr.length;a++)
{
int index = Convert.ToInt32(newArr[a][newArr[a].Length -1]);
//swap whole row with tow at current index
if(index != a)
{
string[] arr2 = arr[a];
arr[a] = arr[index];
arr[index] = arr2;
}
}

Herzlichen Glückwunsch, Sie haben sortiert das array nach der gewünschten Spalte. Diese können Sie ändern, damit es funktioniert mit anderen Datentypen