Sortierung - Algorithmen - Möglichkeiten - Input Liste(x,y)

04/06/2009 - 09:39 von Andreas Ott | Report spam
Hallo,

ich muss eine Liste gemàß diesen 4 Fàllen sortieren.

Fàlle 1 bis 4
http://www1.minpic.de/bild_anzeigen...7&ende

Zum Verstàndnis - Ausgabe für den Fall 2
Màanderformig.
http://www1.minpic.de/bild_anzeigen...06&key860943&ende



Hardware - Aufbau
http://www1.minpic.de/bild_anzeigen...6&ende

Die Maschine hat einen Einlauf und einen Auslauf.
Die Markiereinheit bewegt sich nicht, ist fix!! Es bewegen sich
lediglich die Achsen.

Aufgrund der Markierung müssen diese 4 Wege abgefahren werden.

Ich habe einen Quellcode in C++, diesen ich jetzt nach C# portieren muss.

Welche Klassen, Objekte bieten sich da an?
Wie könnte die Umsetzung aussehen?
Eine std. Library gibt es ja nicht. Was nuimmt man zum sortieren in C#?




Grüße Andreas



Als Anlage der C++ Code.


// Sort_Wege.cpp : Definiert den Einstiegspunkt für die Konsolenanwendung.
//

#include "stdafx.h"
#include "Sort_Wege.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


// Das einzige Anwendungsobjekt

CWinApp theApp;

using namespace std;

#pragma once
#include <vector>
#include <algorithm>

#include <conio.h>
#include <ctype.h>

#include <math.h>
static bool toogle;

vector<double> vorkommendeXWerte;
////static vector<bool> suchrichtung[vorkommendeXWerte.size()];
//bool suchrichtung[1000];
vector<bool> suchrichtung;

static bool GetSuchrichtung(double x)
{
int i=0;
for ( i=0; i<(int)vorkommendeXWerte.size(); ++i )
{
//if ( x == vorkommendeXWerte[i] )
// break;

if ( fabs(x - vorkommendeXWerte[i]) < 0.001 )
break;


/* if ( fabs(x,vorkommendeXWerte[i])<0.001 )
return suchrichtung[i]; */
}
// ** i ist jetzt bekannt --> Suchrichtungsindex aus dem Vektor
Suchrichtung holen
bool richtung = suchrichtung[i];

return richtung;
// ... hier Fehlerbehandlung nicht vergessen
}



class CSortWay
{
public:
CSortWay(){}
CSortWay(double x, double y) { X = x; Y = y; }
~CSortWay(){}
typedef std::vector<CSortWay> data;

public:
double X;
double Y;

//static vector<double> vorkommendeXWerte;
////static vector<bool> suchrichtung[vorkommendeXWerte.size()];
//static vector<bool> suchrichtung[1000];


static bool SortCase1(const CSortWay var1,const CSortWay var2)
{
double x1 = var1.X;
double y1 = var1.Y;

double x2 = var2.X;
double y2 = var2.Y;


/*printf("~~~x1= %7.2f, y1=%7.2f x2= %7.2f, y2=%7.2f ",
x1,
y1,
x2,
y2);*/

return( (x1<x2) || (x1==x2 && y1<y2) );

}

static bool SortCase2(const CSortWay var1,const CSortWay var2)
{
double x1 = var1.X;
double y1 = var1.Y;

double x2 = var2.X;
double y2 = var2.Y;

if ( x1<x2 || x1>x2 )
return false;
else if ( x1==x2 )
{
if ( GetSuchrichtung(x1) )
return y1<y2;
else
return y1>y2;
}
else
return false;
}


static bool SortCase3(const CSortWay var1,const CSortWay var2)
{
double x1 = var1.X;
double y1 = var1.Y;

double x2 = var2.X;
double y2 = var2.Y;

return( (y1<y2) || (y1==y2 && x1<x2) );

}

static bool SortCase4(const CSortWay var1,const CSortWay var2)
{
// ** TODO
double x1 = var1.X;
double y1 = var1.Y;

double x2 = var2.X;
double y2 = var2.Y;

return( (x1*x1 + y1*y1) < (x2*x2 + y2*y2) );
}
};







int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
int nRetCode = 0;

// MFC initialisieren und drucken. Bei Fehlschlag Fehlermeldung aufrufen.
if (!AfxWinInit(::GetModuleHandle(NULL), NULL, ::GetCommandLine(), 0))
{
// TODO: Den Fehlercode an Ihre Anforderungen anpassen.
_tprintf(_T("Schwerwiegender Fehler bei der MFC-Initialisierung"));
nRetCode = 1;
}
else
{
CSortWay::data mylistSortWay;

mylistSortWay.push_back(CSortWay(50,10));
mylistSortWay.push_back(CSortWay(50,20));
mylistSortWay.push_back(CSortWay(50,30));
mylistSortWay.push_back(CSortWay(50,40));

mylistSortWay.push_back(CSortWay(90,10));
mylistSortWay.push_back(CSortWay(90,20));
mylistSortWay.push_back(CSortWay(90,30));
mylistSortWay.push_back(CSortWay(90,40));

mylistSortWay.push_back(CSortWay(10,10));
mylistSortWay.push_back(CSortWay(10,20));
mylistSortWay.push_back(CSortWay(10,30));
mylistSortWay.push_back(CSortWay(10,40));

mylistSortWay.push_back(CSortWay(30,10));
mylistSortWay.push_back(CSortWay(30,20));
mylistSortWay.push_back(CSortWay(30,30));
mylistSortWay.push_back(CSortWay(30,40));

mylistSortWay.push_back(CSortWay(70,10));
mylistSortWay.push_back(CSortWay(70,20));
mylistSortWay.push_back(CSortWay(70,30));
mylistSortWay.push_back(CSortWay(70,40));


// ** Case 1
printf("Case 1");

std::sort(mylistSortWay.begin(),
mylistSortWay.end(),
CSortWay::SortCase1);
int count=0;
for ( CSortWay::data::iterator it2(mylistSortWay.begin());
it2!=mylistSortWay.end();
it2++ )
{
++count;
printf("Pos=%d x= %7.2f, y=%7.2f",
count,
(*it2).X,
(*it2).Y);
}
// ** Case 2
*********************************************************************
printf("Case 2");

// ** nach x sortieren!
std::sort(mylistSortWay.begin(),
mylistSortWay.end(),
CSortWay::SortCase1);

// ** jetzt die Spalten ermitteln
double merkeX = -9999;
vorkommendeXWerte.clear();
for ( CSortWay::data::iterator it2(mylistSortWay.begin());
it2!=mylistSortWay.end();
it2++ )
{
if ( merkeX != (*it2).X )
{
vorkommendeXWerte.push_back((*it2).X);
merkeX = (*it2).X;
}
}
// ** zu den Spalten die Richtungsumkehr ermitteln
bool toggle = false;
for(int i=0;i<(int)vorkommendeXWerte.size();++i)
{
suchrichtung.push_back(toggle);
toggle= !toggle;
}

std::sort(mylistSortWay.begin(),
mylistSortWay.end(),
CSortWay::SortCase2);

count=0;
for ( CSortWay::data::iterator it2(mylistSortWay.begin());
it2!=mylistSortWay.end();
it2++ )
{
++count;
printf("Pos=%d x= %7.2f, y=%7.2f",
count,
(*it2).X,
(*it2).Y);
}
// ** Case 3
printf("Case 3");

std::sort(mylistSortWay.begin(),
mylistSortWay.end(),
CSortWay::SortCase3);
count=0;
for ( CSortWay::data::iterator it2(mylistSortWay.begin());
it2!=mylistSortWay.end();
it2++ )
{
++count;
printf("Pos=%d x= %7.2f, y=%7.2f",
count,
(*it2).X,
(*it2).Y);
}
//// ** Case 4
// printf("Case 4");
//
// std::sort(mylistSortWay.begin(),
// mylistSortWay.end(),
// CSortWay::SortCase4);
// count=0;
// for ( CSortWay::data::iterator it2(mylistSortWay.begin());
// it2!=mylistSortWay.end();
// it2++ )
// {
// ++count;
// printf("Pos=%d x= %7.2f, y=%7.2f",
// count,
// (*it2).X,
// (*it2).Y);
// }
_getch();
}



return nRetCode;
}
 

Lesen sie die antworten

#1 Kerem Gümrükcü
04/06/2009 - 09:53 | Warnen spam
Hallo Andreas,

generell bieten sich da die Generics an, d.h alles aus
dem Namespace "System.Collections.Generic", bzw.
spezielles aus dem Namespace "System.Collections".
So was wie eine STL/ATL/MFC hast Du unter .NET nicht,
aber die CLR und Klassen ist schon mehr als màchtig
genug und Du kannst auch bestimmte Open-Source
oder Third-Party Libraries benutzen die noch mal das
Non-Plus-Ultra zugeben,...

Anbei bemerkt hàttest Du nicht gleich den ganzen Code
posten müssen,...

Suche mal nach den Begriffen "Sorting C#" mit Google/Bing,
da bekommst Du ne riesen Auswahl an Beispielen,...

Grüße

Kerem

Beste Grüsse / Best regards / Votre bien devoue
Kerem Gümrükcü
Latest Project: http://www.pro-it-education.de/soft...iceremover
Latest Open-Source Projects: http://entwicklung.junetz.de
"This reply is provided as is, without warranty express or implied."

Ähnliche fragen