Sortierung 2D-Array in C++

Ist es möglich, zu Sortieren eines 2D-Array mit qsort oder std::sort in C++, so dass die Elemente in aufsteigender Reihenfolge beim Lesen von Links nach rechts in jeder Zeile bzw. von oben nach unten in jeder Spalte?

Beispielsweise

13, 14, 15, 16
1, 4, 3, 2
7, 5, 7, 6
9, 10, 11, 12

Wird:

{ 1, 2, 3, 4 }
{ 5, 6, 7, 8 }
{ 9, 10, 11, 12 }
{ 13, 14, 15, 16 }

Ich weiß, Sie können es tun, indem zwei Funktionen Vergleich und dann die erste Sortierung, die jede Zeile dann beim Vergleich der ersten Elemente in jeder Zeile zu etablieren Spalten, aber gibt es einen Weg, es zu tun in einer Funktion selbst?

Wenn es sich um eine NxN-matrix, dann kopiert die Elemente einer vector. Sortieren Sie die Vektor-und dann kopieren Sie jede Zeile wieder array von vector.
Nicht, dass nur die Zeilen zu Sortieren, obwohl? Was ist mit den Spalten?
Kopieren Sie es in ein Vektor-Art, die es als 1D-array (welches es jetzt ist), und kopieren Sie Sie dann zurück zu den 2D-array.
hmmm ... Wenn der gesamte Vektor wird sortiert, dann kopieren Sie es zurück an array Sortieren Sie die Spalten als gut. Zum Beispiel, wenn 4 ist an NxN-position dann käme es zu 1*N element nach dem Sortieren und kopieren der array - ( Hier N = 4).
Sie können versuchen, auf die Tatsache stützen, dass ein 2D-array ist lediglich die spezielle syntax und es ist angeordnet, die nacheinander im Speicher. Probieren Sie etwas wie: std::sort(&array2d[0][0], &array2d[0][0] + N*M, std::less<int>());

InformationsquelleAutor 1110101001 | 2013-10-08

c++sorting

Ja. C++ STL Bibliothek ist gebaut mit Trennung der algorithmen und Container. Was Sie miteinander verbindet ist Iteratoren. Raw-pointer ist iterator, daher ist es möglich, zu initialisieren Vektor mit raw-Pointern und dann Sortieren, Vektor, wie üblich.

std::vector<int> v(arr2d, arr2d + N); //create a vector based on pointers
                                      //This assumes array is contiguous range 
                                      //in memory, N=number of elemnts in arr2d
//using default comparison (operator <):
std::sort (v.begin(), v.end());

//cout by 4 elements in a row

InformationsquelleAutor 4pie0

# include <iostream>
using namespace std ;


void swap (int &x , int &y)
{
    int temp = x ;
    x = y ;
    y = temp ;
}

void main ()
{
    int arr [3][3] = {{90,80,70},{60,50,40},{30,100,10}} ;
    int x ;

    for (int k = 0; k < 3; k++)
    {
        for (int m = 0; m < 3; m++)
        {
            x = m+1;
            for (int i = k; i < 3 ; i++)
            {
                for (int j = x; j < 3; j++)
                {
                    if (arr [k][m] > arr [i][j])
                        swap(arr [k][m] ,arr [i][j]);
                }
                x=0;
            } 
        }
    }

    for (int i = 0; i < 3; i++)
    {
        for (int j = 0; j < 3; j++)
        {
            cout << arr [i][j] << " ";
        }
    }


    system("pause");
}

C++ Sortierung der 2-D-array ascendingly

Der Fragesteller ersuchte die Antwort "mit qsort oder std::sort"

InformationsquelleAutor Eslam

1

In der Theorie sollten Sie in der Lage sein, die Eingabe der 16 zahlen in einem array. Eine for-Schleife verwenden, vielleicht sogar eine verschachtelte, zum Sortieren der zahlen. Dann bei der Ausgabe, die Sie wollen, die aufsteigende zahlen in vier Gruppen von vier?
```
cout<<Vector[0]<<Vector[1]<<Vector[2]<<Vector[3]<<endl;
cout<<Vector[4]<<Vector[5]<<Vector[6]<<Vector[7]<<endl;
cout<<Vector[8]<<Vector[9]<<Vector[10]<<Vector[11]<<endl;
cout<<Vector[12]<<Vector[13]<<Vector[14]<<Vector[15]<<endl;
```
sehr willkürlich, aber ich bin mir nicht ganz sicher die Frage.

InformationsquelleAutor Macaire Alexander Bell

Zunächst ein 2D-Vektor .

Art jeder Vektor in diesem 2D-Vektor -

Sortieren der ganze Vektor

Code :

#include <iostream>
#include <vector>
#include <algorithm>

template <class T>
void Sort2dArray(std::vector<std::vector<T>> & numbers)
{

    for(auto & i : numbers){//sort each vector<T> in numbers
        std::sort(i.begin(),i.end());
    }
    std::sort(numbers.begin(),numbers.end(),[](//sort numbers by defining custom compare 
              const std::vector<T>& a,const std::vector<T>&b){
        for(int i=0;i<a.size()&&i<b.size();i++)
        {
            if(a[i]>b[i])
                return false;
            else if(a[i]<b[i])
                return true;
        }
        return a.size()<b.size() ? true : false;
    });
}

int main()
{
    std::vector<std::vector<int>> numbers={ {13, 14, 15, 16},
                                            {1, 4, 3, 2},
                                            {8, 5, 7, 6},
                                            {9, 10, 12,11}};
    Sort2dArray(numbers);//sort array

    //write sorted array
    for(auto i:numbers)
    {
        for(auto j:i)
            std::cout<<j<<" ";
        std::cout<<"\n";
    }
}

InformationsquelleAutor Omid

-1

**Sortierung 2D-array in c++**

#include <iostream>

using namespace std;

int main()
{
    int i,j,k,m,temp,n,limit;
    int** p;


    cout<<"Enter the limit:";
    cin>>limit;

    p=new int*[limit];

//inputing
    for(i=0;i<limit;i++)
    {
        p[i] = new int[limit];

        for(j=0;j<limit;j++)
        {
          cin>>p[i][j];
        }

    }

//sorting
    for(i=0;i<limit;i++)
    {
        for(j=0;j<limit;j++)
        {
            if (j==limit-1 && i<limit-1)
            {
                n =-1;
                m=i+1;
            }
            else
            {
                m=i;
                n=j;
            }

            for(k=n+1;k<limit;k++)
            {
                if(p[i][j] > p[m][k] )
                {
                    temp = p[i][j];
                    p[i][j] = p[m][k];
                    p[m][k] = temp;
                }

                if(k==limit-1 && m<limit-1) { m++;  k=-1;  }

            }
        }
    }

    //displaying
    for(i=0;i<limit;i++)
    {
        for(j=0;j<limit;j++)
        {
            cout<<p[i][j]<<endl;
        }

    }

    return 0;
}

InformationsquelleAutor varun

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.