快速排序、归并排序的递归、非递归实现

概述：

快速排序递归实现

void swap(int &a,int &b){
int c =a;
a = b;
b = c;
}
void quicksort(int * a, int start, int end) {
if (start >=end)
return;
int pivot = a[start];
int i = start;
int j = end+1;
while (1) {
do {
i++;
} while (a[i] < pivot);
do {
j--;
}while (a[j] > pivot);
if (i >= j)
break;
swap(a[i], a[j]);
}
a[start] = a[j];
a[j] = pivot;
quicksort(a,start,j-1);
quicksort(a,j+1,end);
}

void quicksort(int * a, int n) {
if (n <= 1)
{
return;
}
quicksort(a, 0, n - 1);
}

快速排序的非递归实现

void swap(int &a, int &b) {
int c = a;
a = b;
b = c;
}
int partition(int * a, int start, int end)      //返回支点pivot的索引！
{
int pivot = a[start];
int i  = start;
int j  = end + 1;
while (1) {
do {i++;} while (a[i] < pivot);
do {j--;} while (a[j] > pivot);
if (i >= j)
break;
swap(a[i], a[j]);
}
a[start] = a[j];
a[j] = pivot;
return j;
}
void quicksort(int* a , int n) {
if (n <= 1)
return;
stack<int> con;
int mid = partition(a, 0, n - 1);
if (0 < mid)
{
c
ce2d
on.push(0);
con.push(mid - 1);
}
if (mid < n - 1)
{
con.push(mid + 1);
con.push(n - 1);
}
while (!con.empty()) {
int r = con.top();      //先放入l 后放入的r因为是栈所以先取出来的是r
con.pop();
int l = con.top();
con.pop();
mid = partition(a, l, r);
if (l< mid-1)
{
con.push(l);
con.push(mid - 1);
}
if (mid+1 < r)
{
con.push(mid + 1);
con.push(r);
}
}
}

void swap(int &a, int &b) {
int c = a;
a = b;
b = c;
}
int partition(int * a, int start, int end)      //返回支点pivot的索引！
{
int pivot = a[start];
int i  = start;
int j  = end + 1;
while (1) {
do {i++;} while (a[i] < pivot);
do {j--;} while (a[j] > pivot);
if (i >= j)
break;
swap(a[i], a[j]);
}
a[start] = a[j];
a[j] = pivot;
return j;
}
void quicksort2(int *a, int n ) {
if (n <= 1)
return;
queue<int> con;
int mid = partition(a, 0, n - 1);
if (0 < mid - 1)
{
con.push(0);
con.push(mid - 1);
}
if (mid + 1 < n - 1)
{
con.push(mid + 1);
con.push(n - 1);
}
while (!con.empty()) {
int l = con.front();            //l先入先取出来的就是l
con.pop();
int r = con.front();
con.pop();
mid = partition(a, l, r);
if (l<mid-1)
{
con.push(l);
con.push(mid-1);
}
if (mid+1<r)
{
con.push(mid+1);
con.push(r);
}
}
}

归并排序的递归实现

void mergesort(int a [], int first, int last, int temp[]);
void mergesort(int a[], int n) {
//mergesort入口
int *p = new int
;
if (n <= 1)
return;
mergesort(a, 0, n - 1, p);
}

void merge(int a[], int first, int mid, int last, int temp[]) {
int i = first; int  j = mid + 1;
int n = mid; int m = last;
int k = 0;
while (i <= mid && j <= last) {
if (a[i] < a[j])
{
temp[k++] = a[i++];
} else {
temp[k++] = a[j++];
}
}
while (i <= mid) {
temp[k++] = a[i++];
}
while (j <= last) {
temp[k++] = a[j++];
}
for (int i = 0; i < k; ++i)
{
a[first + i] = temp[i];
}
}
void mergesort(int a [], int first, int last, int temp[]) {
if (first < last)
{
mergesort(a, first, (first + last) / 2, temp);
mergesort(a, 1 + (first + last) / 2, last, temp);
merge(a, first, (first + last) / 2, last, temp);
}
}

归并排序非递归实现

void merge2(int *a , int *p , int start , int mid , int last) {
int k = start;
int i = start;
int j = mid + 1;
while (i <= mid && j <= last)
if (a[i] <= a[j])
p[k++] = a[i++];
else
p[k++] = a[j++];
while (i <= mid)
p[k++] = a[i++];
while (j <= last)
p[k++] = a[j++];
}
void mergepass(int * a, int * p , int s, int n) {
int i = 0;
while (i + 2 * s <= n) {
merge2(a, p, i, i + s - 1, i + 2 * s - 1);
i += 2 * s;
}
if (i + s <= n - 1) //有两段，也就是说现在的i加上一个segment还不够n所以肯定还有
merge2(a, p, i, i + s - 1, n - 1);
else            //只有一段不到
for (int j = i; j <= n - 1; ++j)
p[j] = a[j];
}
void mergesort2(int a[  ], int n) {
int *p  = new int
;
if (n <= 1)
return;
int s = 1;
while (s < n) {
mergepass(a, p, s, n);
s += s;
mergepass(p, a, s, n);
s += s;
}
}