交换排序-快速排序的非递归算法

//stack.h
#ifndef __STACK_H__
#define __STACK_H__

#include<stdio.h>
#define MaxSize 500
#define FALSE 0
#define TRUE 1
typedef struct stack {
	int top, maxstack;
	int element[MaxSize];
}Stack;
void CreateStack(Stack* s, int m)
{
	s->top = -1;
	s->maxstack = m;
}
int isEmpty(Stack s) {
	return s.top < 0;
}
int isFull(Stack s) {
	return s.top >= s.maxstack - 1;
}
void Push(Stack* s, int x) {
	if (isFull(*s)) {
		printf("OVERFLOW\n");
	}
	else {
		s->element[++s->top] = x;
	}
}
void Pop(Stack* s) {
	if (s->top < 0) {
		printf("UNDERFLOW\n");
	}
	else {
		s->top--;
	}
}
int StackTop(Stack *s,  int* x) {
	if (s->top < 0) {
		printf("UNDERFLOW\n");
		return FALSE;
	}
	else {
		*x = s->element[s->top];
		return TRUE;
	}
}
void PrintStack(Stack s) {
	int i;
	for (i = 0; i <= s.top; i++) {
		printf("%d  ", s.element[i]);
	}
	printf("\n");
}
#endif // !__STACK_H__

#include<stdio.h>
#include<stdlib.h>
#include <string.h>
#include"stack.h"
#define Swap(x,y, t)  ((t)=(x), (x)=(y), (y)=(t))
#define MAXSIZE 100
typedef int T;
typedef struct list {
	int size;
	T elements[MAXSIZE];
}List;
int Paitition(List* lst, int left, int right) {
	int i = left, j = right + 1; T temp;
	T pivot = lst->elements[left];
	do
	{
		do
		{
			i++;
		} while (pivot > lst->elements[i]);
		do
		{
			j--;
		} while (pivot < lst->elements[j]);
		if (i < j)
		{
			Swap(lst->elements[i], lst->elements[j], temp);
		}
	} while (i < j);
	Swap(lst->elements[left], lst->elements[j], temp);
	return j;
}

void QSort(List* lst, int left, int right) {
	int k;
	Stack* s= (Stack*)malloc(sizeof(Stack));
	int _left = left;
	int _right = right;
	CreateStack(s, MAXSIZE);

	if (left < right)
	{
		FLAG:
		while (_left< _right)
		{
			k = Paitition(lst, _left, _right);
			if (k != _right)
			{
				Push(s, k + 1);
				Push(s, _right);
			}
			_right = k - 1;
			//k = Paitition(lst, _left, k - 1);
		}
		if (isEmpty(*s) ) {
			return;
		}
		StackTop(s , &_right);
		Pop(s);
		StackTop(s , &_left);
		Pop(s);
		goto FLAG;
	}
}
void QuickSort(List* lst) {
	QSort(lst, 0, lst->size - 1);
}
void main() {
	int i;
	List* lst = (List*)malloc(sizeof(List));
	lst->size = 9;
	//lst->elements
	lst->elements[0] = 72;
	lst->elements[1] = 26;
	lst->elements[2] = 57;
	lst->elements[3] = 88;
	lst->elements[4] = 42;
	lst->elements[5] = 80;
	lst->elements[6] = 73;
	lst->elements[7] = 48;
	lst->elements[8] = 60;
	QuickSort(lst);
	//memcpy(lst->elements, temp, 10);
	for (i = 0; i < 9; i++)
	{
		printf("%d \n", lst->elements[i]);
	}
}

result:

26
42
48
57
60
72
73
80
88