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

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

#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, " "));
}

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

#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;
}