前面我們講解了快速排序的遞迴實現，但若是待排序的數量非常大且雜亂無章，每層迴圈都使用遞迴呼叫，會很容易造成棧溢位，所以我們可以將快速排序設計為非遞迴實現。 遞迴實現快速排序演算法詳解   快速排序是從序列中選擇一個基準值，按照某種方式將該區間分成兩部分，基準值左側所有元素比基準值小，基準值右側所有元素比基準值大。然後排基準值左側部分，排基準值右側部分。   若想把快速排序改成迴圈最重要的是將基準值右側區間的下標記住，排完左邊序列之後排右邊序列。 步驟：   1. 申請一個棧，存放排序陣列的起始位置和終點位置。    2. 將整個陣列的起始位置0和終點位置size入棧。    3. 由於棧的特性是：後進先出，size後進棧，所以size先出棧。定義一個right接收棧頂元素，出棧操作、定義一個left接收棧頂元素，出棧操作。    4. 對陣列進行一次快排，返回基準值的下標。    5. 這時候需要排基準值左邊的序列。如果只將基準值左邊序列的起始位置和終點位置存入棧中，等左邊排序完將找不到後邊的區間。所以先將右邊序列的起始位置和終點位置存入棧中，在將左邊的起始位置和終點位置存入棧中。    6.判斷棧是否為空，若不為空 重複4、5步、若為空則排序完成。 程式碼實現：

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<assert.h>
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;
}