利用递归和循环实现快速排序

#include <iostream>
#include <queue>
using namespace std;
typedef std::pair<int ,int> queue_data;
queue<queue_data> my_queue;
void swap(int &a,int&b){
    int temp = a;
    a = b;
    b = temp;
}

int partionArray(int * array,int begin,int end){
    int key = array[end];
    int i = begin-1;
    for (int j = i+1;j<end;j++){
        if(array[j]<=key){
            i=i+1;
            swap(array[i],array[j]);
        }
    }
    swap(array[i+1],array[end]);
    return i+1;
}
void quickSort(int *array,int begin ,int end){
    if(begin<end){
        int k =partionArray(array ,begin,end);
        quickSort(array,begin,k-1);
        quickSort(array,k+1,end);
    }
}
void quickSortUseLoop(int *array,int begin ,int end){
    queue_data begin_end= make_pair(begin,end);
    my_queue.push(begin_end);
    while (!my_queue.empty()){
        queue_data begin_end = my_queue.front();
        my_queue.pop();
        int k = partionArray(array,begin_end.first,begin_end.second);
        if(begin_end.first<k-1) {
            my_queue.push(make_pair(begin_end.first, k - 1));
        }
        if(k+1<begin_end.second){
            my_queue.push(make_pair(k+1,begin_end.second));
        }
    }


}
int main(){
    int array_new[]={-1,3,2,6,7,5,9};
    int array[]={-1,3,2,6,7,5,9};
    int length = sizeof(array)/ sizeof(int);
    quickSort(array,0,length-1);
    std::cout << "------------ recursion function ----------------"<<std::endl;
    for(auto i:array){
        std::cout << " "<<i<<std::endl;
    }
    std::cout << "------------ loop function ----------------"<<std::endl;

    int length_new = sizeof(array_new)/ sizeof(int);
    quickSortUseLoop(array_new,0,length_new-1);
    for(auto i:array_new){
        std::cout << " "<<i<<std::endl;
    }
}

循环与递归方式的快排思想一致，递归时，先将数组分成两个部分，之后分别再对这两个部分递归排序。for循环就是将分组的前半部和后半部的起始和结束位置记录下来，再进行分组。