Algoritmo comentado!

QuickSort.c

void swap(int *a, int i, int j)
{
  int t = a[i];
	a[i] = a[j];
	a[j] = t;
}

int partition(int *a, int left, int right, int pivot)
{
	// Pos é uma variável que auxilia as trocas durante o processo de ordenação,
	// assumindo em alguns momentos o valor do pivo, como em outroras valores de
	// elegiveis à troca.
	// Nota: Todos os elementos à esquerda do pos SÃO menores que o pivo, e todos
	//		elementos a direita do pos não pode-se concluir nada até que processo termine,
	//		mas quando terminado, estes serão maiores que o pivo.
	int pos = 0;
	// Variável de iteração.
	int i = 0;

	// Move (troca) o valor do Pivor para o mais a direita possível,
	// deste modo, pode-se finalizar o processo sem que o pivor seja
	// movido durante o mesmo. Ao final, deve-se move-lo novamente.
	// Nota: o valor que está no indice do "pivot", neste momento,
	//		 não é mais o do pivo e sim o do último elemento da lista.
	//		PORTANTO, O PIVO ESTÁ EM v[right] E NÃO EM v[pivot] APÓS ESTE PASSO!
	swap(a, pivot, right);

	//Define o pos como o valor mais a esquerda possível.
	pos = left;

	//Inicia o Loop de left até right.
	for(i = left; i < right; i++)
	{
		// Verifica se o elemento no indice i é menor que o pivor (que está na extrema direita).
		// Nota: Isto faz com que todos os elementos à esquerda de pos sejam menores que o Pivo(v[right]).
		if (a[i] < a[right])
		{
			//Troca o elemento e incrementa pos.
			swap(a, i, pos);
			pos++;
		}
	}

	//Realiza a ultima troca, movendo o pivo para posição correta.
	//Nota: a[right] ou somente right permenaceu inalterado durante todo o processo.
	//      Como mostrado no inicio, o ultimo elemento do vetor foi alterado com o pivo,
	//		sendo assim, temos que right é o pivo.
	//		Neste ponto, tem-se no vetor, um bloco de elementos menores e outro bloco com
	//		elementos maiores que o pivor, onde o indice que divide estes 2 blocos está salvo em pos.
	//		Por tanto, deve-se no final realizar a troca entre o right e o pos, pois quem deve dividir
	//		os dois blocos (de menores e maiores) é o pivo.
	swap(a, right, pos);

	// Retorna a nova posição do Pivo, pós particionamento.
	return pos; 
}

void quick(int *a, int left, int right)
{
	if (left < right)
	{
		//Define o Pivor como o elemento médio.
		int pivot = (left+right) / 2;
		// Salva a posição do Pivo pós partição.
		int pos = partition(a, left, right, pivot);
		// Recursividade. 
		// Repete o processo para a partição à esquerda do Pivo.
		quick(a, left, pos - 1);
		// Repete o processo para a partição à direita do Pivo.
		quick(a, pos + 1, right);
	}
}