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

快速排序的基本思想

快速排序是冒泡排序的一种改进，其基本思想是通过一趟排序将数据分割成独立的两部分，其中一部分的所有数据都比另一部分的所有数据小，然后按此方法分别对这两部分数据进行快速排序，依次进行从而达到使整个数据变得有序。

快速排序的实现原理

如上图示：首先，设置好基准轴Pivot，设置待排序区间的左右边界记为L、R，将L从左向右遍历，遇到比Pivot大的就放在轴的右边，将R从右向左遍历，遇到比Pivot小的，就放在轴的左边。直到L和R位置重合，一旦重合，就将Pivot放到该位置，那就完成了一次排序

递归实现（C++）

#include<iostream> 
#include<stdlib.h>
using namespace std;
//完成一次快速排序，返回的下标为分割点，接下来要将分割点
//左右边两部分进行快速排序 
int quickSortOneTime(int arr[], int low, int high){
	int basic = arr[low];
	while(low < high){
		while(low < high && arr[high] >= basic) {
			high--;
		}
		if(low < high) arr[low] = arr[high];
		while(low < high && arr[low] <= basic){
			low++;
		}
		if(low < high) arr[high] = arr[low];
	}
	arr[low] = basic;
	return low;
}
//递归实现快速排序 
void quickSort1(int arr[], int low, int high) {
	if(low < high){
		int mid = quickSortOneTime(arr, low, high);
		quickSort1(arr, low, mid-1);
		quickSort1(arr, mid+1, high);
	}
}
void print(int arr[]){
	int num = 7;
	for(int i = 0; i < num; i++){
		cout << arr[i] << "*";
	}
}
int main(){
	int arr1[7] = {7,6,5,4,3,2,1};
	quickSort1(arr1, 0, 6);
	print(arr1);
	return 0;
}

非递归实现（C++）

使用堆栈，堆栈使用单向链表实现

#include<iostream> 
#include<stdlib.h>
using namespace std;
//使用单链表创造堆栈，结点要指向开头，易删除和插入 
typedef struct SNode *stack;
struct SNode{
	int data;
	stack top; 
}; 
//完成一次快速排序，返回的下标为分割点，接下来要将分割点
//左右边两部分进行快速排序 
int quickSortOneTime(int arr[], int low, int high){
	int basic = arr[low];
	while(low < high){
		while(low < high && arr[high] >= basic) {
			high--;
		}
		if(low < high) arr[low] = arr[high];
		while(low < high && arr[low] <= basic){
			low++;
		}
		if(low < high) arr[high] = arr[low];
	}
	arr[low] = basic;
	return low;
}
//创建堆栈，创建一个头结点，不存放数据，指针指向NULL 
stack makeStack(){
	stack s;
	s = (stack)malloc(sizeof(struct SNode));
	s->top = NULL;
	return s;
}
//入栈 
void push(stack s, int x){
	stack p;
	p = (stack)malloc(sizeof(struct SNode));
	p->data = x;
	p->top = s->top;
	s->top = p;
}
//判断堆栈是否为空，返回值为布尔类型 
bool isEmpty(stack s){
	if(!s->top) return true;
	else return false;
}

//出栈
int pop(stack s){
	if(isEmpty(s)){
		return -1;
	}else{
		stack p = s->top;
		int mid = p->data;
		s->top = p->top;
		free(p);//释放空间 
		return mid;
	}
} 
//非递归实现快速排序，使用压栈
void quickSort2(int arr[], stack s, int low, int high){
	if(low < high){
		//此时堆栈为空，进行第一次快速排序 
		int mid = quickSortOneTime(arr, low, high);
		if(low < mid-1){
			push(s, low);
			push(s, mid-1);
		}
		if(mid+1 < high){
			push(s, mid+1);
			push(s, high);
		}
		//只要堆栈不空，就代表还有子区间内待排序，因此循环 
		while(!isEmpty(s)){
			int high = pop(s);
			int low = pop(s);
			//出栈获得区间下标，进行排序 
			mid = quickSortOneTime(arr, low, high);
			//如果子区间依旧需要排序则依次入栈 
			if(low < mid-1){
				push(s, low);
				push(s, mid-1);
			}
			if(mid+1 < high){
				push(s, mid+1);
				push(s, high);
			}
		}
	}
} 

void print(int arr[]){
	int num = 7;
	for(int i = 0; i < num; i++){
		cout << arr[i] << "*";
	}
}
int main(){
	int arr2[7] = {17,16,15,14,13,12,11};
	stack s = makeStack();
	quickSort2(arr2, s, 0, 6);
	print(arr2);
	return 0;
}

参考
[1]: https://www.cnblogs.com/zhangchaoyang/articles/2234815.html