快速排序的非递归实现-----c语言

  前面我们讲解了快速排序的递归实现，但若是待排序的数量非常大且杂乱无章，每层循环都使用递归调用，会很容易造成栈溢出，所以我们可以将快速排序设计为非递归实现。
递归实现快速排序算法详解
  快速排序是从序列中选择一个基准值，按照某种方式将该区间分成两部分，基准值左侧所有元素比基准值小，基准值右侧所有元素比基准值大。然后排基准值左侧部分，排基准值右侧部分。
  若想把快速排序改成循环最重要的是将基准值右侧区间的下标记住，排完左边序列之后排右边序列。
步骤：
   1. 申请一个栈，存放排序数组的起始位置和终点位置。
   2. 将整个数组的起始位置0和终点位置size入栈。
   3. 由于栈的特性是：后进先出，size后进栈，所以size先出栈。定义一个right接收栈顶元素，出栈操作、定义一个left接收栈顶元素，出栈操作。
   4. 对数组进行一次快排，返回基准值的下标。
   5. 这时候需要排基准值左边的序列。如果只将基准值左边序列的起始位置和终点位置存入栈中，等左边排序完将找不到后边的区间。所以先将右边序列的起始位置和终点位置存入栈中，在将左边的起始位置和终点位置存入栈中。
   6.判断栈是否为空，若不为空 重复4、5步、若为空则排序完成。
代码实现：

#include
#include
#include
#include
void Print(int *arr,int size);
//非递归快速排序
void quickSortNor(int *arr, int size);
typedef struct Stack{
	int *data;
	int size;
	
}stack;


void  InitStack(stack *s)
{
	int *data = (int*)malloc(20 * sizeof(int));
	if (data == NULL)
	{
		assert(0);
		return;
	}
	s->data = data;
	s->size = 0;
}
void PushStack(stack *s,int d)
{
	assert(s);
	if (s->size > 20)
	{
		return;
	}
	else
		s->data[s->size++] = d;
}
void PopStack(stack *s)
{
	assert(s);
	if (s->size == 0)
	{
		return;
	}
	else
		s->size--;
}
int TopStack(stack *s)
{
	assert(s);
	return s->data[s->size-1];
		
}
int EmptyStack(stack *s)
{
	assert(s);
	return s->size == 0;
}
//打印函数
void Print(int *arr, int size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

void swap(int *x, int *y)

{
	/*int tmp = *x;
	*x = *y;
	*y = tmp;*/
	*x = ((*x) ^ (*y));
	*y = ((*x) ^ (*y));
	*x = ((*x) ^ (*y));
}
int MiddleNumber(int *arr, int begin, int end)
{
	int mid = begin + ((end - begin) >> 1);
	if (arr[begin] > arr[mid])
	{
		if (arr[begin] > arr[end])
		{
			if (arr[mid] > arr[end])
			{
				return mid;
			}
			else
				return end;
		}
		else
			return begin;
	}
	else
	{
		if (arr[mid] > arr[end])
		{
			if (arr[begin] > arr[end])
			{
				return begin;
			}
			else
			{
				return end;
			}
		}
		else
			return mid;
	}
	
}
/*
  挖坑法
  先将最后一个元素标记设置为第一个坑
  设置两个指针begin、end
  begin从左边开始找比关键字大的元素将其入坑，begin所在位置变为坑
  end从右边开始找比关键字小的元素将其入坑,end所在位置变为坑
  知道begin==end将标记的第一个元素入坑
*/
int qs2(int *arr, int begin, int end)
{
	//找基准
	/*
	由于每次规划取到最大值或最小值的概率
	都非常高，这样容易使树变成单支树，所以采用三数取中法
	来降低取到最值的概率
	*/
	int index = MiddleNumber(arr, begin, end);
	if (index != end)
	{
		swap(&arr[index], &arr[end]);
	}

	//第一个坑
	int key = arr[end];
	int k = end;
	while (begin != end)
	{
		/*begin从左边开始找比关键字大的元素将其入坑
		，begin所在位置变为坑*/
		while (arr[begin] <= key&&begin < end)
		{
			begin++;
		}
		if (begin != end)
		{
			arr[end] = arr[begin];
			end--;
		}
		/*end从右开始找比关键字小的元素将其入begin坑*/
		while (arr[end] >= key&&begin < end)
		{
			end--;
		}
		if (begin != end)
		{
			arr[begin] = arr[end];
			begin++;
		}
	}
	if (begin != k)
	{
		arr[begin] = key;
	}
	return begin;
}
//快速排序1
void quickSortNor(int *arr, int size)
{
	stack s;
	int position;
	int left = 0;
	int right = 0;
	InitStack(&s);
	PushStack(&s, 0);
	PushStack(&s, size);
	while (!EmptyStack(&s))
	{
		right = TopStack(&s);
		PopStack(&s);
		left=TopStack(&s);
		PopStack(&s);
		position = qs2(arr, left, right - 1);
		//先快排基准左侧，则先将后侧的下标入栈
		if ((right - left) > position + 1)
		{
			PushStack(&s, position + 1);
			PushStack(&s, right - left);
		}
		if (position > 0)
		{
			PushStack(&s, 0);
			PushStack(&s, position);
		}
	}
}

测试文件：

#include"quickSort.h"

void TestquickSort()
{
	int array[] = {2,5,4,9,3,6,8,7,1,0};
	//打印
	printf("排序前: ");
	Print(array, sizeof(array) / sizeof(array[0]));
	//快速排序
	quickSortNor(array, sizeof(array) / sizeof(array[0]));
	printf("排序后: ");
	Print(array, sizeof(array) / sizeof(array[0]));

}
int main()
{
	TestquickSort();
	system("pause");
	return 0;
}