Questa è la versione iterativa ( non ricorsiva ) del QuickSort per le liste :

Linked List :
codice:
Persona * QuickSortNonRecursive(Persona *first, int list_start, int list_end) 
{
Persona *pivot, *left = first, *right = first, *tmp;
int i, j;
int s = 0;

int stack[64];

if (list_end <= list_start)
	return first;

stack[s++] = list_start;
stack[s++] = list_end;

while ( s > 0 )
{
	list_end = stack[--s];
	list_start = stack[--s];

	if ( list_start >= list_end )
		continue;

	// INIZIO PARTIZIONAMENTO

	i = list_start;
	j = list_end - 1;

	right = GetNthNode(list_end, first);
	left = GetNthNode(list_start, first);
	pivot = SelectPivot(left, right);
	right = FindPrev(pivot, left);

	for(;;)
	{
		for(; ((*Confronta)(left, pivot) < 0); left = left->next, i++);

		for(; ((*Confronta)(right, pivot) > 0) ; right = FindPrev(right, first), j--);

		if ( i >= j )
			break;
	
		first = SwapNodes(left, right, first);
		tmp = left;
		left = right;
		right = tmp;
	}

	// Ripristina il pivot
	first = SwapNodes(left, pivot, first); 

	// FINE PARTIZIONAMENTO

	if (i - list_start > list_end - i)
	{
		stack[s++] = list_start;
		stack[s++] = i - 1;
		stack[s++] = i + 1;
		stack[s++] = list_end;
	}
	else
	{
		stack[s++] = i + 1;
		stack[s++] = list_end;
		stack[s++] = list_start;
		stack[s++] = i - 1;
	}
}

return first;
}
Double Linked List :
codice:
Persona * QuickSortNonRecursive(Persona *first, int list_start, int list_end) 
{
Persona *pivot, *left = first, *right = first, *tmp;
int i, j;
int s = 0;

int stack[64];

if (list_end <= list_start)
	return first;

stack[s++] = list_start;
stack[s++] = list_end;

while ( s > 0 )
{
	list_end = stack[--s];
	list_start = stack[--s];

	if ( list_start >= list_end )
		continue;

	// INIZIO PARTIZIONAMENTO

	i = list_start;
	j = list_end - 1;

	right = GetNthNode(list_end, first);
	left = GetNthNode(list_start, first);
	pivot = SelectPivot(left, right);
	right = pivot->prev;

	for(;;)
	{
		for(; ( (*Confronta)(left, pivot) < 0 ); left = left->next, i++);

		for(; ( (*Confronta)(right, pivot) > 0 ) ; right = right->prev, j--);

		if ( i >= j )
			break;
	
		first = SwapNodes(left, right, first);
		tmp = left;
		left = right;
		right = tmp;
	}

	// Ripristina il pivot
	first = SwapNodes(left, pivot, first); 

	// FINE PARTIZIONAMENTO

	if (i - list_start > list_end - i)
	{
		stack[s++] = list_start;
		stack[s++] = i - 1;
		stack[s++] = i + 1;
		stack[s++] = list_end;
	}
	else
	{
		stack[s++] = i + 1;
		stack[s++] = list_end;
		stack[s++] = list_start;
		stack[s++] = i - 1;
	}
}

return first;
}
nella funzione 'QSort', sostituiamo la chiamata a 'quicksort' con 'QuickSortNonRecursive' :

codice:
// Wrapper per la funzione 'quicksort'
Persona *QSort(Persona *first)
{
	int n;
  
	n = countnodes(first);

	// Chiama la funzione 'quicksort'
	// Numeriamo gli elementi da 1 a n
	// invece che da 0 a n-1

	//return quicksort(first, 1, n);

	return QuickSortNonRecursive(first, 1, n);
}