Stapelvergrößerung funktioniert nicht

Question

Wie kann ich den verfügbaren Stapel für ein Programm mit Bloodshed Dev C++ oder Code::Block richtig erhöhen? Im läuft einfache Blase und schnelle Sortierung, die Arbeit, aber wenn ich den Stapel in Code::Block geändert (herausgefunden, wie über aquí ) führte es dazu, dass mein Programm noch schneller abstürzte, obwohl es viel mehr Platz als vorgeschlagen beanspruchte. Ursprünglich stürzte das Programm beim Sortieren von 64K zufälliger Ganzzahlen ab (unter Verwendung der rand() Funktion). Jetzt, seine Absturz bei 32K. im immer den Fehler: Process returned -1073741571 (0xC00000FD)

das Programm läuft tatsächlich schneller, ohne dass der Stapel geändert wird, vorausgesetzt, ich mache es richtig. gcc -Wl,--stack,1099511627776

Ich kann nicht herausfinden, wie man es überhaupt in Dev C++ ändern kann.

Was soll ich tun? Gibt es eine Möglichkeit, den Stapel innerhalb des Codes selbst zu ändern? Hier ist der Code im mit für Blase und schnelle Sortierung. es gibt zwei von jedem: eine ist mit Vektoren, die andere ist mit Arrays. ich denke, dass die Blase sortieren. sollte korrekt sein. die schnelle Sortierung, im nicht so sicher über. sorry, wenn es ein bisschen unordentlich

vector <int> v_bubble(vector <int> array){
    // Vector Bubble Sort
    if (array.size() < 2){
        return array;
    }
    int s = 1;
    while (s){
        s = 0;
        for (unsigned int x = 0; x < (array.size() - 1); x++){
            if (array[x] > array[x + 1]){
                int t = array[x];
                array[x] = array[x + 1];
                array[x + 1] = t;
                s = 1;
            }
        }
    }
    return array;
}

void a_bubble(int array[], int size){
    // Array Bubble Sort
    int s = 1;
    while (s){
        s = 0;
        for (int x = 0; x < (size - 1); x++){
            if (array[x] > array[x + 1]){
                int t = array[x];
                array[x] = array[x + 1];
                array[x + 1] = t;
                s = 1;
            }
        }
    }
}

vector <int> v_quick(vector <int> array){
    //Vector Quick Sort
    if (array.size() < 2){
        return array;
    }
    vector <int> left;
    vector <int> right;
    int p_location = array.size() / 2 - 1;
    int pivot = array[p_location];
    for(unsigned int x = p_location; x < array.size() - 1; x++){
        array[x] = array[x + 1];
    }
    array.pop_back();
    for(unsigned int x = 0; x < array.size(); x++){
        if (array[x] <= pivot) {
            left.push_back(array[x]);
        }
        else if (array[x] > pivot){
            right.push_back(array[x]);
        }
    }
    vector <int> p;
    p.push_back(pivot);
    return combine(combine(v_quick(left), p), v_quick(right));
}

int a_quick(int array[], int size, int l_index = -1, int r_index = -1){
    //Array Quick Sort
    if (size < 2){
        return array[size];
    }
    array[size] = array[size];
    int left[size];
    int right[size];
    l_index = 0;
    r_index = 0;
    int p_location = size / 2 - 1;
    int pivot = array[p_location];
    for(int x = p_location; x < size - 1; x++){
        array[x] = array[x + 1];
    }
    size--;
    for(unsigned int x = 0; x < size; x++){
        if (array[x] <= pivot) {
            left[l_index] = array[x];
            l_index++;
        }
        else if (array[x] > pivot){
            right[r_index] = array[x];
            r_index++;
        }
    }
    return a_quick(left, l_index, l_index, r_index) + pivot + a_quick(right, r_index, l_index, r_index);
}

der Rest des Codes ist einfach Generierung von Arrays und Vektoren mit 32, 64 und 128 k Einträge, Sortieren von ihnen mit dem obigen Code und Rückgabe der Zeit. dieser Teil im ziemlich sicher, dass ich nicht vermasseln

mein Hauptprogramm besteht im Grunde nur aus

    start = clock();
    a_quick(array1, 32000);
    end = clock();
    cout << "\nQuick Sort\tArray\t32000\t" << ((double) end - start)/CLOCKS_PER_SEC << " seconds\n";

immer und immer wieder