# Größte Zahl suchen



## dannyberlin (20. Mai 2003)

Hi Alle,

ich hab leider nicht gefunden, was ich gesucht hab. Und zwar will ich in C++ nicht einen definierten String suchen, sondern in einem Bereich die größte Zahl.

Genauer heisst das:
ich habe einen Vektor in dem ein Element ID heisst, diesen durchlaufe ich mit einer for-Schleife. Jetzt möchte ich aus diesen Elementen die größte Zahl raussuchen und diese um 1 inkrementieren?

Ich möchte also quasi das auto_increment von mySQL programmieren  Langsam hab ich leider echt keine Ideen mehr. Hoffe, es kann mir jemand weiterhelfen??


```
for (int i=0; i < Vektor.size(); i++)
{
  // vergleiche jede Zahl mit jeder und gucke welche die größte ist
}
```

Viele Grüße,
Daniel


----------



## Dario Linsky (20. Mai 2003)

Eine Möglichkeit wäre es, erst die Elemente der Größe nach zu sortieren und dann direkt das letzte zu nehmen. Such mal bei Google, es gibt verschiedene Sortieralgorithmen, meistens sogar schon mit einem fertigen Code-Beispiel.
Eventuell kannst Du auch einfach eins der Sortierverfahren auf Deine Bedürfnisse anpassen.


----------



## dannyberlin (20. Mai 2003)

verdammt! ich dachte ich komme um diese verdammten sortier-algorithmen irgendwie drumrum.  aber falls nicht zufällig doch noch jemand ne andere idee hat, werde ich das wohl oder übel machen müssen


----------



## SOB (20. Mai 2003)

Du mußt doch sowieso jede Zahl mit jeder vergleichen, das ist doch schon ein halber Sortieralgorithmus. 
Und wenn man sich ein wenig damit auseinandersetzt, sind die auch garnicht sooo schlimm.


----------



## Dario Linsky (20. Mai 2003)

Wieso willst Du denn keine Sortieralgorithmen benutzen bzw. anpassen? Beispielsweise macht ein Bubblesort auch nichts anderes, als die Zahlen untereinander zu vergleichen und dann die jeweils grösste Zahl im Vektor etwas nach hinten zu verschieben. Das könntest Du doch eigentlich prima für Dich verwenden, und so besonders schwer zu verstehen ist das auch nicht unbedingt.


----------



## Frankdfe (20. Mai 2003)

Warum nicht so:


```
int groesste_id = 0;

for (int i=1; i < Vektor.size(); i++)
{
    if (Vektorelement[i] > Vektorelement[groesste_id])
       id = i;

}
```


----------



## Valentin- (20. Mai 2003)

für sowas gibt es auch while() ...


----------



## dannyberlin (20. Mai 2003)

@frankdfe

funktioniert solange die nächste zahl größer ist, als die vorhergehende. sonst leider nicht. aber sowas kurzes knappes hatte ich erhofft. und dann fangt ihr alle mit sortier-algorithmen an, heul :-( *lol*


```
const char* sID;
		int iID;
		int groesste_id = 0;

		for (int j=1; j < vBenutzer.size(); j++)
		{
			sID = vBenutzer[j].id.c_str();
			iID = atoi(sID);

			if (iID > groesste_id)
				groesste_id = j;
		}
		cout << groesste_id;
```

das cout am ende gibt 4 aus, wenn die ids diese reihenfolge haben: 1, 2, 4, 6, 5, 3

mein problem dabei war noch, dass ich nen string in dem vektor habe, der erhöht werden muss.


----------



## Frankdfe (20. Mai 2003)

@valentin-
wieso soll ich aus einer for-Schleife, die von i=1 bis size zählt eine while-Schleife machen?

@dannyberlin
Ich glaube ich hab da was nicht richtig verstanden. Du suchst doch die größte ID(das ist in deinem Beispiel die 6)? 
Und genau das kommt heraus wenn du am Ende


```
vBenutzer[groesste_id].id.c_str();
```
machst (vielleicht war der Name groesste_id wohl doch nicht der passendste; mit ID war die Nummer des Benutzers gemeint)


----------



## Valentin- (20. Mai 2003)

while(int i <  Vektor.size())
{


}


----------



## Dario Linsky (20. Mai 2003)

for-Schleifen sind trotzdem besser als while-Schleifen, weil da alles wichtige schon direkt im Schleifenkopf steht. Bei while-Schleifen kann man schnell mal vergessen, die Zählervariable zu erhöhen und man landet in einer Endlosschleife - aber der Compiler übersetzt alles anstandslos. Das kann bei for nicht passieren.
Schleifen mit while sind eher geeignet, wenn Du mit booleschen Variablen arbeitest:

```
while (!variable)
{
    variable = funktion();
}
```


----------



## Daniel Toplak (20. Mai 2003)

Ich gehe mal davon aus, daß dein Vektor Elemente vom Typ int enthält, dann kannst du einfach einen #define verwenden, der den minimalen Wert eines Integers enthält.
Dann kannst du in einer Schleife die Werte vergleichen und feststellen, welches Element das größte ist.

```
#include <limits.h> // dort stehen die defines drin
#include <iostream>

int highvalue = INT_MIN;
for (int i=0; i < Vektor.size(); i++)
{
  if(Vektor[i] > highvalue)
    highvalue = Vektor[i];
}
cout << highvalue; // das ist dann dein größter Wert
```

Gruss Homer


----------



## rook (20. Mai 2003)

du hast nur was vergessen homer.... 
wenn die reihenfolge nun so aussieht.... 1, 2, 42, 4, 6
dann ist 42 die größte zahl, aber da er der reihe nach geht, ist dann auch wiederrum 6 größer als die 4, und dann wäre für das progamm 6 die größte zahl...

hab hier mal ein anderes beispiel, is aber doch sicher gleich mit den vektoren?!


```
#include <stdio.h>

int main(int argc, char **argv)
{

	int IDs[] = {1, 42, 4, 6, 5, 3, 235, 2, 6824, 1, 0, -45};
	int iID = 0, last = 0;
	
	for(int i = 0; i < (sizeof(IDs)/sizeof(int)); i++)
	{
		if(IDs[i] > last)
			iID = IDs[i];

		if(last < IDs[i])
			last = IDs[i];

	}

	printf("Die Groesste Zahl ist: %i\n", iID);
	return 0;
}
```


----------



## Daniel Toplak (21. Mai 2003)

> du hast nur was vergessen homer....
> wenn die reihenfolge nun so aussieht.... 1, 2, 42, 4, 6
> dann ist 42 die größte zahl, aber da er der reihe nach geht, ist dann auch wiederrum 6 größer als die 4, und dann wäre für das progamm 6 die größte zahl...


Ähm sorry, aber schau dir mal den Quellcode genauer an, denn die 
Reihenfolge spiel überhaupt keine Rolle. Die highvalue Variable
wird zunächst mal auf einen minimalen integer Wert gesetzt und
dann wird jedes Element überprüft, ob es größer als diese
highvalue ist, wenn ja, dann wir der Wert highvalue zugewiesen.
(Standartalgorithmus für min/max)

Gruss Homer


----------



## Thomas Darimont (21. Mai 2003)

Servus!

Wäre es nicht effizienter den Vector zuerst mit qicksort / mergesort zu sortieren, dann die länge des Vectors festzustellen und anschliessend das letzte Element auszuwählen ?

Gruss Tom


----------



## Dario Linsky (21. Mai 2003)

> _Original geschrieben von tdar2 _
> *Servus!
> 
> Wäre es nicht effizienter den Vector zuerst mit qicksort / mergesort zu sortieren, dann die länge des Vectors festzustellen und anschliessend das letzte Element auszuwählen ?
> ...



In dem Fall wär es sogar noch etwas einfacher, das Array absteigend zu sortieren. Dabei sparst Du Dir den zweiten Schritt, weil Du direkt auf das erste Element zugreifen kannst.


----------



## Thomas Darimont (21. Mai 2003)

Servus!



> In dem Fall wär es sogar noch etwas einfacher, das Array absteigend zu sortieren. Dabei sparst Du Dir den zweiten Schritt, weil Du direkt auf das erste Element zugreifen kannst.



Stimmt!

Gruss Tom


----------



## dannyberlin (21. Mai 2003)

Goil!

Erst hatte ich gar keine Möglichkeiten und jetzt sogar 2 zur Auswahl, vielen Dank rook und homer! Eure beiden Scripte funktionieren. Aber auch danke an alle anderen, die sich bemüht haben

Die IDs sind in dem Vektor nen String und müssen daher vorher nochmal konvertiert werden. Hier jetzt die beiden Versionen von rook und homer für mich angepasst:

```
const char* sID;
	int iID;

	int highvalue = INT_MIN;
	for (int j=0; j < Vektor.size(); j++)
	{
		sID = Vektor[j].id.c_str();
		iID = atoi(sID);

		if(iID > highvalue)
			highvalue = iID;
	}

	stringstream intToStr;
	intToStr << highvalue+1;
	intToStr >> put.id;
	intToStr.clear();
```


```
const char* sID;
	int iID;

	int temp, last=0;

	for(int j = 0; j < Vektor.size(); j++)
	{

		sID = Vektor[j].id.c_str();
		iID = atoi(sID);
		
		if(iID > last)
			temp = iID;

		if(last < iID)
			last = iID;
	}

	stringstream intToStr;
	intToStr << temp+1;
	intToStr >> put.id;
	intToStr.clear();
```

@Homer
Das limits.h ist nicht Ansi-kompatibel, oder? Das ist dummerweise Vorgabe bei dem Programm  Wobei bei mir eh Sachen mit drin sind, die nicht drin sein sollten, egal. Hab jetzt rooks Version genommen, trotzdem vielen Dank alle Beteiligten.


----------



## rook (21. Mai 2003)

tschuldige homer... das is mir garnich aufgefallen *g*
ich war zu sehr in mein programm vertieft....


----------



## Daniel Toplak (21. Mai 2003)

> Das limits.h ist nicht Ansi-kompatibel, oder?


Ich glaube schon, denn man kann es auch unter UNIX verwenden, denn es ist Teil der libc.
Außerdem könntest du dir diesen define auch selbst erstellen:

Auszug aus der limits.h der libc unter Linux

```
/* Minimum and maximum values a `signed int' can hold.  */
#  define INT_MAX       2147483647
#  define INT_MIN       (-INT_MAX - 1)

/* Maximum value an `unsigned int' can hold.  (Minimum is 0.)  */
#  define UINT_MAX      4294967295U
```
Aber Vorsicht: Unterschiede zwischen signed und unsigned !!!



> tschuldige homer... das is mir garnich aufgefallen *g*
> ich war zu sehr in mein programm vertieft....


Kein problem *g*

Gruss Homer


----------



## dannyberlin (22. Mai 2003)

> _Original geschrieben von homer _
> *Ich glaube schon, denn man kann es auch unter UNIX verwenden, denn es ist Teil der libc.
> Außerdem könntest du dir diesen define auch selbst erstellen:
> *



Ah, wieder was gelernt. Ich mach erst seit nem 3/4 Jahr ne Ausbildung und hab C++ vorher noch nie gesehen <- das zu meiner Entschuldigung


----------



## Daniel Toplak (22. Mai 2003)

Äm sowas brauchst du nicht entschuldigen.
Man kann ja nicht alles wissen. *g*
Ich wusste es auch nicht, aber ich hatte zufällig gerade eine Linux-Kiste da und hab hald schnell nachgeschaut.

Gruss Homer


----------

