Denkanstoss int-array (sortieren)

borg schrieb:

unno_er schrieb:

okay, ich glaub ich hab mich nich gaaanz korrekt ausgedrückt: also ich will nich, dass das array sortiert wird, sondern dass ich in einer for()-schleife das array durchgehen kann, aber in der reihenfolge von größtem wert zum kleinsten....

aha!
na dann hat SeppSchrot doch vollkommen recht, absteigend sortieren und dann das array von unten nach oben durchlaufen.

ja, aber den array-index muss ich beibehalten, den brauch ich (der dient mir praktisch als ID)...

leech

#include <iostream>
using namespace std;

int main()
{
    const int laenge = 5;
    int array[laenge] = { 5, 15, 7, 94, 1};

    for( int i = 0; i < laenge; i++)
    {
        int index = 0;
        for(int y = 0;  y < laenge; y++)
        {
            if(array[y] > array[index])
                        index = y;
        }    
        cout << array[index] << endl;
        array[index] = -1;
    } 
    cin.get();
    return 0;   
}

wenn negative zahlen im array vorkommen, dann musst du das obere abändern...

borg

void ausgabe_von_gross_nach_klein( int *arr, int laenge )
{
  int index = 0;
  int naechst_groesster_wert = arr[index_vom_groessten_wert( arr, laenge )] + 1;
  for( int j = 0; j < laenge; j++ )
  {
    for( int i = 1; i < laenge; i++ )
      if( arr[i] > arr[index] && arr[i] < naechst_groesster_wert )
         index = i;
    naechst_groesster_wert = arr[index];
    cout << "ID: " << index << ", Wert: " << arr[index] << endl;
  }
}

also so? wofür genau brauchst du das denn? gibt bestimmt eine performantere lösung für dein problem

also ich hab es hinbekommen, dass er es richtig sortiert und so.... aber ich wenn ein wert zweimal vorkommt, dann lässt er den aus.. und ich hab keine ahnung wie ich das machen kann:

int go = 0;
	for(int i=0; i<LAENGE; i++)
		if(elements[i] > 0)
		{
			if(go == 0)
			{
				_id[0] = i;
				_times[0] = elements[i];
			}
			for(int j=0; j<LAENGE; j++)
				if(elements[j] > 0)
				{
					if(go == 0 && elements[j] > _times[go])
					{
						_id[go] = j;
						_times[go] = elements[j];
					}
					else
					{
						if(elements[j] > _times[go] && elements[j] < _times[(go-1)] && _id[(go-1)] != j)
						{
							_id[go] = j;
							_times[go] = elements[j];
						}
						else if(elements[j] == _times[go] && elements[j] < _times[(go-1)] && _id[(go-1)] != j)
						{
							_id[(go+1)] = j;
							_times[(go+1)] = elements[j];
						}
					}
				}
			go++;
		}

hier in dem code hab ich das schon irgendwie versucht hinzubekommen, aber es werden stattdessen von den doppelten zwar doppelte erstellet jedoch mit der falschen ID dazu... ich kriegs einfach nich hin und bin schon kurz davor meine tastatur gegen den monitor zu hauen...

bzw so:

if(elements[j] > _times[go] && elements[j] < _times[(go-1)] && _id[(go-1)] != j && _id[(go+1)] != j)
						{
							_id[go] = j;
							_times[go] = elements[j];
						}
						else if(elements[j] == _times[go] && elements[j] < _times[(go-1)] && _id[(go-1)] != j && _id[(go+1)] != j)
						{
							_id[(go+1)] = j;
							_times[(go+1)] = elements[j];
						}

macht er fast alles richtig. jedoch wenn z.b. dort etwas den wert 2 z.b. 6mal enthalten hat dann werden davon max. 2 erstellt

okay ich nochmal
ich hab das jetzt so hingekriegt. ich habe 15 items und davon wurden aber nur 14 als größer eingetragen und das zweitgrößte war am ende nicht dabei. das zweitgrößte ist "elements[0]"...

for(int i=0; i<LAENGE; i++)
		if(elements[i] > 0)
		{
			for(int j=0; j<LAENGE; j++)
				if(elements[j] > 0)
				{

						bool alreadyin = false;
						for(int j2=0; j2<LAENGE; j2++)
							if(_id[j2] == j) alreadyin = true;
						if(elements[j] > _times[go] && alreadyin == false)
						{
							_id[go] = j;
							_times[go] = elements[j];
						}
						else if(elements[j] == _times[go] && alreadyin == false)
						{
							_id[(go+1)] = j;
							_times[(go+1)] = elements[j];
						}
				}
			go++;
		}

okay okay... hab schon!

Hallo,
also ich dachte eigentlich ich habs, aber habs doch nicht. Er Speichert den zweitgrößten Wert nicht ab o_O:

int _id[length] = {0};
	int _times[length] = {0};
	int go = 0;
	int h_id = 0;
	int h_times = 0;
	for(int i=0; i<length; i++)
		if(elements[i] > 0)
			if(elements[i] > h_times)
			{
				h_times = elements[i];
				h_id = i;
			}
	_id[0] = h_id;
	_times[0] = h_times;
	for(int i=0; i<length; i++)
		if(elements[i] > 0)
		{
			for(int j=0; j<length; j++)
				if(elements[j] > 0)
				{
					bool alreadyin = false;
					for(int j2=0; j2<length; j2++)
						if(_id[j2] == j) alreadyin = true;
					if(elements[j] > _times[go] && alreadyin == false)
					{
						_id[go] = j;
						_times[go] = elements[j];
					}
					else if(elements[j] == _times[go] && alreadyin == false)
					{
						_id[(go+1)] = j;
						_times[(go+1)] = elements[j];
					}
				}
			go++;
		}

hat jemand eine ahnung? DANKE DANKE!

borg

wie wärs wenn du ein zweites array erstellst, welches structs dieser form beinhaltet:

struct liste
{
  int id;
  int wert;
}

und dieses dann mit einem adäquaterem sortierverfahren sortierst?

oder wie wärs mit

std::map<int, int>

?
imo das was du suchst.

hmm, kann man das nicht irgendwie auf eigene weise machen? mein code funktioniert ja eigentlich, nur eben leider nich ganz perfekt.

borg

eine lösung hab ich oben schon gepostet, anstatt es auszugeben kannst du es natürlich auch in 2 weitere arrays schreiben.

wofür sind in deinem code die

if(elements[i] > 0)

?

hmm, kann man das nicht irgendwie auf eigene weise machen?

definiere "eigene weise"

die if-abfragen sollen dazu dienen, dass keine leeren einträge übernommen werden