2d array

E

eye

Hallo...

ich bin ein Maschinenbaustudent, und muss gerade in Datenverarbeitung 2 ein c/c++ Programm schreiben.

Meine Aufgabe :

Sortieralgorithmus für einen zweidimensionalen Vektor. Dazu ist im ersten Schritt vom Benutzer die Zeilenzahl Z und die Spaltenzahl S abzufragen. Anschließend ist der Vektor mit Werten zu füllen (Verwenden Sie den Zufallsgenerator).
Im letzten Schritt sind die Werte über einen entsprechenden Algorithmus der Größe nach wahlweise aufwärts/abwärts zu sortieren, d.h. in der ZxS-Matrixdarstellung steht z.B. der kleinste Wert in der Ecke links oben (Element [0][0]) und der größte Wert steht in der Ecke rechts unten (Element [Z-1][S-1])

Mein Problem: Ich bekomme zwar alle Zeilen einzelnd sortiert, aber nicht das alles miteinander verglichen wird.

Irgendwie muss da noch eine If Bedingung rein, aber ich weiß nicht wie und nicht wo...

Bitte um Hilfe..


Hier mein Code..

Code: 
# include <iostream.h>
# include <time.h> 
# include <stdlib.h> 

 
int main() 
{ 
	int Matrix[10][10]; 
	int trans; 
	int i,j,q,test,anzw,l,b,k,temp,p,temp1;  // sind zu viele variablen, die kommen  
                                                                   // aber durch das testen
 

	cout << "Geben Sie die Spalten ein: " ; 
	cin >> anzw; 
	cout << "Geben Sie die Zeilen ein: " ; 
	cin >> l; 

 
//zufallsgenerator

	srand(time (0));
	for (b=0; b<anzw; b++)
	{ 
		for (j=0; j<l; j++)
		{ 

			Matrix[b][j] = rand() % 100;
		} 
	} 



// hier tauchen die Probleme auf


for(p=0;p<anzw;p++)
{
	for(k=0;k<l-1;k++)
		for(i=k+1;i<l;i++)
			if(Matrix[p][k]>Matrix[p][i])
			{
				
					temp=Matrix[p][k];
					Matrix[p][k]=Matrix[p][i];
					Matrix[p][i]=temp;



			}




}





			for(b=0;b<anzw;b++)
			{
			
				for(j=0; j<l; j++)
				{
					cout<< "  "<< Matrix[b][j];
				}
				cout<<endl;
			}


}
 
So habs dir mal schnell geschrieben:

algorithm.hpp
C++: 
#if !defined (ALGORITHM_HPP__INCLUDED)
#define ALGORITHM_HPP__INCLUDED

#include <cstdlib> 
#include <algorithm>

namespace algorithm
{
    // bubblesort algorithm for pointer-array
    template <typename data_type>
    void bubble_sort(data_type** data, std::size_t size)
    {
        bool swapped(false);
        
        do
        {
            --size;
            swapped = false;
            
            for (std::size_t i(0); i < size; ++i)
                if (*data[i] > *data[i + 1])
                { 
                    std::swap(*data[i], *data[i + 1]);
                    swapped = true;
                }
        } while (swapped == true);
    }

    // random number generator (srand will once be called)
    template<typename value_type>
    struct random
    {
        random(const std::size_t seed, value_type const& min, value_type const& max)
            : min(min), max(max)
        { 
            static bool initialised(false);
            if (initialised == false) { std::srand(seed); initialised = true; }
        }
        
        value_type operator ()() const
        { return min + static_cast<value_type>((max - min + 1) * std::rand() / (RAND_MAX + 1.0)); }

        void set_range(value_type const& min, value_type const& max)
        { min = min; max = max; }

    private:
        value_type min;
        value_type max;
    };
}; // algorithm

#endif // ALGORITHM_HPP__INCLUDED
main.cpp
C++: 
#include <algorithm>
#include <vector>
#include <iostream>
#include <ctime> 
#include <iterator>
#include "algorithm.hpp"

typedef std::vector<int> column_t;

int main() 
{ 
    // zufallszahlengenerator erstellen (zeit als startwert)
    algorithm::random<int> random_generator(static_cast<unsigned>(std::time(NULL)), 0U, 100U);

    // benutzer nach spalten und zeilenanzahl fragen
    std::cout << "Spaltenanzahl: "; 
    std::size_t row_count(0);
    std::cin >> row_count; 
    std::cout << "Zeilenanzahl: ";
    std::size_t col_count(0);
    std::cin >> col_count;

    // 2d-array (matrix) erstellen
    std::vector< column_t > data_matrix(col_count, column_t(row_count, 0));
    std::clog << "Matrix mit Zufallsdaten füllen ..." << std::endl;

    // zufallsdaten generieren und daten anzeigen 
    for (std::vector< column_t >::iterator it(data_matrix.begin()); it != data_matrix.end(); ++it)
    {
        std::generate(it->begin(), it->end(), random_generator);
        std::copy(it->begin(), it->end(), std::ostream_iterator<int>(std::clog, " "));
        std::clog << std::endl;
    }
    
    std::clog << "\n2D-Array auf 1D-Array per Zeiger blitten ... (Zugriff auf Elemente col|row: col * row_count + row)" << std::endl;

    // 2d-array auf 1d-pointer-array
    // element col|row ist: col * width_array + row.
    std::vector<int*> data_matrix_ptr(col_count * row_count, NULL);
    for (std::size_t i(0); i < data_matrix_ptr.size(); ++i)
        data_matrix_ptr[i] = &data_matrix[i / row_count][i % row_count];

    // sortieren
    std::clog << "Sortieren (BubbleSort-Algorithmus) ..." << std::endl;
    algorithm::bubble_sort(&data_matrix_ptr[0], data_matrix_ptr.size());

    // sortierten 2d-array ausgeben
    for (std::vector< column_t >::iterator it(data_matrix.begin()); it != data_matrix.end(); ++it)
    {
        std::copy(it->begin(), it->end(), std::ostream_iterator<int>(std::clog, " "));
        std::clog << std::endl;
    }
}
... sollte so problemlos gehen ;)
 
wow...

super das das so schnell ging.. aber da versteh ich ja nichts von =D

ich muss das auch erklären können... und das haben wir noch laange nicht gehabt ..


also so wie mein prof. das meinte soll ich das erste Element [0][0] vergleichen mit [0][0],[0][1],[0][2] und dann sollen die halt vertauscht werden wenn die andere größen haben und dann soll das element weiter verglichen und vertauscht werden mit den [1][0],[1][1],[1][2] und das dann auch beliebig viele spalten und zeilen...

sorry für die Umstände.. aber deins is zu hoch
 
Nja dann sollte der Prof mal überlegen ob das sinnvoll ist ;) Nen 2D-Array lässt sich ohne weiters auf nen 1D-Array blitten und damit kannst du dann hingehen und jeden beliebigen Algorithmus, den du auf nen 1D-Array loslassen kannst, darauf loslassen.
 
hm... ja das wird bestimmt sinnvoll sein wenn du das sagst..

nur leider bringt mich das in meinem Fall nicht weiter. Wenn vll noch irgendjemand einen Lösungsvorschlag hat, der zu meiner Beschreibung passt... bitte posten...

danke schonmal im vorraus aber auch danke an devDevil für die Mühe

LG
 
Du solltest aufjedenfall wissen das mehrdimensionale Arrays im Rechner als eindimensionales Array gespeichert werden und du sie mit der richtigen Syntax demzufolge auch als eindimensionales Array behandeln kannst. Denn die gängigen Sortieralgorythmen sind nur bzw. logischerweise auf eindimensionale Arrays anwendbar.
Mal ein bissl das Netz durchforsten.

Der Prof meint bestimmt den Bubblesort-Algorythmus...

mfg:)
 
bubbelsort... ja =D

ich glaube sowas hat er schonmal in den Mund genommen...

wenn ich das mit meinem Quelltext vergleiche sieht mir das auch sehr stark nach diesem bubble sort aus.. komme halt da nur net weiter...

aber ich google mal nach deinen sachen...
 
So hab nochmal Zeit gefunden und es selbst ausprobiert :)
Das sollte dir helfen, man nennt es Pointerarithmetik.

C++: 
#include <iostream>

int main()
{
    using namespace std;
    const int len = 10;
    int Matrix[len][len];
    for (int i = 0; i < len*len; i++)
    {
      *(*(Matrix)+i) = i;
      cout << *(*(Matrix)+i) << endl;
    }


	return 0;
}
 
also das sieht schon ganz gut aus...

nur das mit den * versteh ich nicht... das sind doch zeiger oder bin ich da falsch ?
sowas hatten wir noch nicht.. hab mich da versucht reinzulesen... aber irgendwie ist das sehr schwierig...
aber ich versuche es weiter, vll schaff ich das ja noch

ansonsten sagte mir das ich mit meinem programm auch schon sehr na dran bin, da halt nur eine if bedingung noch fehlt.. wenn jemand weiß die diese heißt.. bitte um post

lg
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück