1.) Ich habe folgenden Code und ich frage mich, warum kein Fehler oder zumindestens kein uninitialisiertes Element, also eine irre hohe Zahl erscheint:

void MinSort(int *arr, int n)
{
	int temp=0, min=0;
	for(int i=0; i<n; ++i)
	{
			min=i;
			for	(int j=i+1; j<n; ++j)
				if(arr[j] < arr[min]) min=j;
			temp=arr[min];
			arr[min]=arr[i];
			arr[i]=temp;
	}
}

int main()
{
	int arr[]={8,7,6,5,4,3,2,1};
	MinSort(arr,9); //Das Array ist aber nicht so groß

	for (int i=0; i<9; i++) //Es kommt aber kein Fehler
		cout << arr[i] << "   ";
	//Ausgabe: 0,1,2,3,4,5,6,7,8  --> Warum???
	return 0;
}

2.) Ich interessiere mich für die Komplexität von Algorithmen und habe mir den entsprechenden Abschnitt in Wikipedia durchgelesen. Laut wikipedia ist der Best Case von SelectionSort und von BubbleSort gleich, da diese Formel gilt:

O = ((n-1)*n)/2

Das kann doch gar nicht sein, da MinSort meines Wissens effizienter ist. Was ist hier falsch?

Vielen Dank
lg, freakC++

2. Ich verstehe nicht, was du daran nicht verstehst. Wikipedia hat völlig recht. Weißt du überhaupt, was Best Case bedeutet?

2.) Ich interessiere mich für die Komplexität von Algorithmen und habe mir den entsprechenden Abschnitt in Wikipedia durchgelesen. Laut wikipedia ist der Best Case von SelectionSort und von BubbleSort gleich, da diese Formel gilt:

O = ((n-1)*n)/2

Das kann doch gar nicht sein, da MinSort meines Wissens effizienter ist. Was ist hier falsch?

Vielen Dank
lg, freakC++

Das was du da angibts ist die Best Case Laufzeit, die überhaupt keine Aussagekraft hat.
Die Worst Case Laufzeit ist aussagekräftiger

Das was du da angibts ist die Best Case Laufzeit, die überhaupt keine Aussagekraft hat.
Die Worst Case Laufzeit ist aussagekräftiger

falsch. so wie er da steht ist der auch im best case quadratisch.

zu 1) Ok, ich dachte, dass dies jetzt nicht nach einem undefinierten Verhalten aussieht, wenn genau an der richtigen Stelle die richtige Zahl eingefügt wird.

zu 2) Also Best- und Wost - Case sind die idealsten Fälle und die arbeitsintensivsten Fälle eines Algorithmus. Beim BubbleSort wäre das also, wenn von klein nach groß sortieren möchte, doch das Array die Zahlen 4,3,2,1 - also genau die falsche Reihenfolge, enthält. Ich verstehe aber nicht, warum bei SelectionSort (Min) und bei BubbleSort das gleiche steht, das beide doch verschieden effizient sind. Außerdem kommt es doch immer auf die Implementation an, da man auch dadurch einen Algorithmus schneller machen kann. Beispieil:

void BubbleSort(int *arr, int n) 
{ 
 for (int i = n-1; i > 0; i--) 
 { 
  for (int j = 0; j < i; j++) //ich kann auch immer bis n-1 laufen lassen
  {                           //das wäre aber nicht so effizient
   if (arr[j] > arr[j + 1]) 
   { 
    int swp = arr[j]; 
    arr[j] = arr[j + 1]; 
    arr[j + 1] = swp; 
   } 
  } 
 } 
}

Vielen Dank für eure Hilfe
lg, freakC++

lg, freakC++

So gefunden: http://www.youtube.com/watch?v=JPyuH4qXLZ0. In der 1. Vorlesung erklärt er Insertionsort und Mergesort und analysiert jeweils die Laufzeit (recht informell).

Kannst Du mir eine gute Quelle nennen? Wikipedia reicht anscheinend nicht!

Mich.

Aber ich habe heute keine Zeit einen langen Beitrag darüber zu schreiben. Vielleicht hat jemand anderes ja mehr Zeit oder eine andere gute Quelle.

Du musst auch keinen langen Beitrag schreiben ;). Solange Du meine Fragen kurz beantwortest ist mir schon sehr geholfen. Da ich aber weiß, dass Du das machst, ist ja alles im grünen Bereich

Bis bald
lg, freakC++

Best Case: : Ο=n
Worst Case: Ο=(n(n-1))/2

Vielen Dank
lg, freakC++

Bedeutet dies also, dass die Effiziez von BubbleSort und MinSort gleich ist.

Ja, wobei Bubblesort in der Regel größere Konstanten hat. Aber wenn ein sehr geschickter Programmierer Bubblesort schreibt und ein sehr ungeschickter Programmierer MinSort schreibt, könnten beide gleich schnell sein.

Jedoch hat MinSort meines Wissens nach einen BestCase von O(n^2), ist da also tatsächlich schlechter als Bubblesort. Was aber wie schon erwähnt völlig unbedeutend ist.

Fazit: Für größere Datenmengen sind beide unbrauchbar. Und auch bei sehr kleinen Datenmengen gibt es Verfahren die (normalerweise) kleinere Konstanten aufweisen.

(Definition von Konstanten:
Der Zeitfaktor der noch an die Komplexitätsklasse ranmultipliziert wird um die wirkliche Laufzeit zu bekommen. Diese ist stark implementierungsabhängig.)

Wichtig ist wohl dieser n0 Punkt. Wenn ich beispielsweise einen Algorithmus habe, der die Laufzeit O(n^2) hat und ein anderer O(n^3), dann schneiden die sich. Wenn ich den ersteren auf einem Pc laufen lasse und den letzteren auf einem Supercomputer und gegen unendlich gehe, dann wird der PC gewinnen, obwohl er eine niedrigere Leistung hat.

Ok, doch ich hatte eine Klausuraufgabe, in der eine Zahlenfolge gegeben war und man sollte nun herausfinden, wie viele Vergleiche und Vertauschungen (best und worse case) mit dem BubbleSort und dem MinSort nötig sind. Ist das nicht schwachsinnig, denn da kommt es wirklich auf die Implementation an!!!

Vielen Dank
lg, freakC++

Ok, doch ich hatte eine Klausuraufgabe, in der eine Zahlenfolge gegeben war und man sollte nun herausfinden, wie viele Vergleiche und Vertauschungen (best und worse case) mit dem BubbleSort und dem MinSort nötig sind. Ist das nicht schwachsinnig, denn da kommt es wirklich auf die Implementation an!!!

Nein. Die Implementierung sollte nichts am Algorithmus ändern. Wenn man bei der Implementierung vom Original abweicht, dann kann sich das natürlich ändern, aber dann implementiert man eben auch nicht mehr den Algorithmus (sondern irgendeine Variation dessen)

Also in der Vorlesung wurde gesagt, das InsertSort den Worst Case von O(n^2) hat, also wie bei BubbleSort und MinSort. Weiter oben habe ich jedoch geschrieben, dass der Worst Case Ο=(n(n-1))/2 ist. Was ist nun richtig?

2.) Schaut euch mal bitte die Tabelle auf dieser Seite an:

http://www.cprogramming.com/tutorial/computersciencetheory/sortcomp.html

Da sind beispielsweise bei BubbleSort und SelectionSort best/worse Case immer gleich aber laut Vorlesung gilt doch:

Worst Case: θ(n^2 )
Best Case: θ(n)

Ich habe in diesem Gebiet noch gar keine Erfahrungen gemacht, weshalb die Fragen vielleicht ein bisschen doof sind :xmas1:

Vielen Dank
lg, freakC++

Mmhh, ok.

Also in der Vorlesung wurde gesagt, das InsertSort den Worst Case von O(n^2) hat, also wie bei BubbleSort und MinSort. Weiter oben habe ich jedoch geschrieben, dass der Worst Case Ο=(n(n-1))/2 ist. Was ist nun richtig?

Rechne doch mal nach, von welcher Ordnung (n(n-1))/2 ist. Das ist O(n^2).

2.) Schaut euch mal bitte die Tabelle auf dieser Seite an:

http://www.cprogramming.com/tutorial/computersciencetheory/sortcomp.html

Da sind beispielsweise bei BubbleSort und SelectionSort best/worse Case immer gleich aber laut Vorlesung gilt doch:

Worst Case: θ(n^2 )
Best Case: θ(n)

Ich habe in diesem Gebiet noch gar keine Erfahrungen gemacht, weshalb die Fragen vielleicht ein bisschen doof sind :xmas1:

Vielen Dank
lg, freakC++

Ihr habt in der Vorlesung offenbar das gemacht, was auf der Seite als "Modified Bubble sort" bezeichnet wird.

Ne, mit Vorlesung meine ich den Link der ganz am Anfang gepostet wurde. Ich bin noch in der Schule, weshalb die Fragen manchmal blöd sind....

Ich kann aber nun schreiben (denn so habe ich wikipedia) verstanden, dass für

Insert, Selection, Shake und Bubble gilt:

Worst Case: θ(n^2 )
Best Case: θ(n)

Doch was meint dann meine gepostete Website?

Vielen, vielen Dank
lg, freakC++