Arrays und ihre Verarbeitung

[antrax]

Hallo an alle,

da ich neu bin, möchte ich mich erstmal vorstellen.
Meine Name ist Christian, ich bin 17 Jahre alt und lebe als Schüler in NRW.

Nun zum Thema meines Posts.
Ich soll für die Schule einen QuickSort Algorithmus implementieren(rekursives Soriterverfahren).
Nun müssen wir dies im Unterricht mit Delphi berwerkstelligen, da ich mich gegen diese Sprache wehre will ich es nun mit C++ versuchen.
Ich habe mich in früher Vergangenheit mit der Sprache schon mal beschäftigt und versuche mich nun erneut an ihr.
Nun hatte ich mir den Aufbau meine Programmes im Commandozeilenstil recht simpel vorgestellt.
Es wird ein Array erstellt, mit Zufallszahlen gefüllt, an eine Funktion übergeben und diese gibt dann das sortierte Array zurück.
Daraufhin sollen natürlich die Zahlen ausgegeben werden.

Da ich noch relativ blutiger Anfänger bin poste ich nun erstmal meinen Quellcode:
//FehlerBearbeitung Zeile 27

#include<iostream>
using namespace std;

int QuickSort(int, int, int);

int main()
{
    int array[50];
    for(int i=1;i<50;i++)
    {
            array[i]=rand();
    }
    for(int i=1;i<50;i++)
    {
            cout<<array[i]<<"\n";
    }
    system("Pause");
    cout<<"Sortiere";
    QuickSort(1,50,array[50]);
}

int QuickSort(int l, int r, int array[50])
{
    int i;
    i=l;
    int j;
    j=r; //i=j; war falsch
    int trennwert;
    trennwert=array[(l+r)/2];
    do
    {
      while(array[i]<trennwert)
      {
       i++;
      }
      while(trennwert<array[j])
      {
       j--;
      }
      if(i<=j)
      {
              swap(array[i],array[j]);
              i++;
              j--;
      }
    }while(i>j);

    if(l<j)
    {
           QuickSort(l,j,array[50]);
    }
    if(i<r)
    {
           QuickSort(i,r,array[50]);
    }
    return array[50];
}

Ich weiß, dass das Programm in diesem Zustand noch wenig ergibt, da es die bearbeiteten Daten nicht mal ausgibt.
Ich habe aber atm eher Probleme mit der Verarbeitung und Übergabe von Arrays und
erbitte daher freundlichst eure Hilfe.

Danke schon mal vorweg

mfg antrax

[Checker*amp*Murckser]

spontan fällt mir Zeile 27 auf, wo du i j zuweist, ohne, dass du j initialisiert hast, das kann so nicht stimmen ...

/Edit: Beschäftige dich noch mal mit Arrays ..., da passen einige Dinge nicht

[*D*Evil]

Öhm nutzt einfach mal die Standard-Library ...

#include <algorithm>
#include <iterator>
#include <functional>
#include <iostream>

template <typename T>
void quick_sort(T& begin, T& end) 
{
    if (begin != end) 
	{
		T middle = std::partition(begin, end, std::bind2nd(std::less<std::iterator_traits<T>::value_type>(), *begin));
        quick_sort(begin, middle);
		quick_sort(std::max(begin + 1, middle), end);
    }
}

int main()
{
	std::vector<std::size_t> nums(25);
	for (std::size_t n = 0; n < 25; ++n)
		nums.push_back(n);

	std::random_shuffle(nums.begin(), nums.end());
	std::copy(nums.begin(), nums.end(), std::ostream_iterator<std::size_t>(std::cout, " "));
	quick_sort(nums.begin(), nums.end());
	std::copy(nums.begin(), nums.end(), std::ostream_iterator<std::size_t>(std::cout, " "));
}

[antrax]

hallo

Diese Methode mag wohl funktionieren und ich danke dir auch sehr für die Mühe (D)Evil, die du dir damit bereitet hast, doch muss ich leider den gegebenen Algorithmus implementieren.
Es hapert bei mir ganz simpel am übergeben des Arrays.
Sollte ich das über ne globale Variable machen?
Oder ist es sinnvoller mit Referenzen zu arbeiten?
Eigentlich soll ja folgendes geschehen:
Es wird ein Arrays erstellt.
Das Arrays wird mit Hilfe des Algorithmus bearbeitet.
Das Array wird ausgegebn.

mfg

Antraxx

[*D*Evil]

na für gewöhnlich machst du es einfach mit einem Pointer ... int* test, const std::size_t size ... d.h. du gibst auch die Größe mit an ... damit keine Oberläufe stattfinden können.

[antrax]

ist es denn richtig, dass zeiger von keinem gültigskeitsbreich abhängig sind?
dh. eigentlich existiert in der funktion die variable nicht, aber der pointer zeigt einfach auf einen speicherbereich in dem diese variable dann "zufällig" gespeichert ist?
wie sieht es denn da mit schreiben in den datenbereich aus?

[*D*Evil]

?

#include <iostream>

void test(const int*, const std::size_t);

int main()
{
    int a[256];
    test(a, 256);
}

void test(const int* data, const std::size_t size)
{
    for (std::size_t i = 0; i < size; ++i)
        std::cout << data[i] << std::endl;
}