Ordenando vetor com Quick Sort

O vetor é preenchido por um contador,
e em seguida seus elementos são embaralhados
para que possam passar por um bloco de ordenação
com quick sort.
Só queria deixar claro uma coisa.
Por mais que agente altere os nomes das variáveis,
num código de ordenação, como este mesmo do exemplo,
que é o quick sort, tido como um dos mais produtivo no que faz,
isto não quer dizer que somos os donos do código,
as alterações dos nomes das variáveis ou algumas
meras modificações no código original só satisfaz
nossos gostos ou otimiza de acordo com o sistema usado.
A história do quick sort é impressinante,
ele foi desenvolvido em 1960 pelo cientista da computação
britânico Charles Antony Richard Hoare,
também conhecido como Tony Hoare ou C. A. R. 
Mas só após uma série de refinamentos o algoritmo foi publicado em 1962.
Procure por mais informações sobre o quick sort na internet,
que com certeza encontrará dezenas de links sobre o assunto.

Veja abaixo imagens do programa em execução:

Veja abaixo o código do programa

#include <windows.h>

#include <stdio.h>

#include <conio.h>

#include <stdLib.h>

#include <time.h>

#define TAM 100

bool x = false;

/*============================================================================*/

void Informe ( ) {

     textcolor ( LIGHTBLUE );

     gotoxy ( 26, 20 );

     printf ( "Criado por: " );

     textcolor ( LIGHTMAGENTA );

     gotoxy ( 126, 20 );

     printf ( "Samuel Lima" );

     textcolor ( BLACK );

     gotoxy ( 23, 23 );

     printf ( "                                " );

     gotoxy ( 26, 21 );

     printf ( "sa_sp10@hotmail.com" );

     textcolor ( LIGHTRED );

     gotoxy ( 36 , 23 );

     printf ( "MUITO OBRIGADO" );

}

/*============================================================================*/

//Criando uma moldura na tela do dos

int Moldura ( int tam_lin_ini, int tam_lin_fim,

         int tam_ini_col, int tam_fim_col ) {

     int i, c;

     for ( i = tam_lin_ini; i < tam_lin_fim; i++ ) {

         for ( c = tam_ini_col; c < tam_fim_col; c++ ) {

              gotoxy ( c, i );

              textbackground ( WHITE );

              printf ( " " );

         }

     }

     return 0;

}

/*============================================================================*/

void Quick_Sort ( int vetor [ TAM ], int ini, int fim ) {

     int temp, men, mar;

     int aux,  met;

     men = ini;

     mar = fim;

     met = ( int ) ( ( men + mar ) / 2 );

     temp = vetor [ met ];

     do {

         while ( vetor [ men ] < temp )

              men = men + 1;

         while ( vetor [ mar ] > temp )

              mar = mar - 1;

         if ( men <= mar ) {

              aux = vetor [ men ];

              vetor [ men ] = vetor [ mar ];

              vetor [ mar ] = aux;

              men = men + 1;

              mar = mar - 1;

         }

     } while ( mar > men );

     if ( ini < mar )

         Quick_Sort ( vetor, ini, mar );

     if ( men < fim )

         Quick_Sort ( vetor, men, fim );

     x = true;

}

/*============================================================================*/

int Cria_Vetor ( int vet [ ] ) {

     textcolor ( LIGHTRED );

     gotoxy ( 23 , 3 );

     printf ( "ORDENANDO UM VETOR COM QUICK SORT" );

     int i, r = 0, temp;

     for ( i = 0; i < TAM; i++ ) {

         vet [ i ] = i;

     }

     srand ( time ( NULL ) );

     for ( i = 0; i < TAM; i++ ) {

         r = rand ( ) % TAM;

         temp = vet [ i ];

         vet [ i ] = vet [ r ];

         vet [ r ] = temp;

     }

     return 0;

}

/*====================================================================*/

void Imprime_Vetor ( int vet [ ] ) {

     int i;

     gotoxy ( 25, 7 );

     for ( i = 0; i < TAM; i++ ) {

         if ( i == 10 ) {

              gotoxy ( 25, 8 );

         }

         if ( i == 20 ) {

              gotoxy ( 25, 9 );

         }

         if ( i == 30 ) {

              gotoxy ( 25, 10 );

         }

         if ( i == 40 ) {

              gotoxy ( 25, 11 );

         }

         if ( i == 50 ) {

              gotoxy ( 25, 12 );

         }

         if ( i == 60 ) {

              gotoxy ( 25, 13 );

         }

         if ( i == 70 ) {

              gotoxy ( 25, 14 );

         }

         if ( i == 80 ) {

              gotoxy ( 25, 15 );

         }

         if ( i == 90 ) {

              gotoxy ( 25, 16 );

         }

         if ( vet [ i ] >= 0 && vet [ i ] < 10 ) {

              textcolor ( BLUE );

              printf ( "0" );

         }

         //Para impressão do vetor desordenado

         if ( x == false ) {

              textcolor ( BLUE );

              printf ( "%d ", vet [ i ] );

         }

         //Para impressão do vetor ordenado

         if ( x == true ) {

              textcolor ( BLUE );

              printf ( "%d ", vet [ i ] );

         }

     }//chave de fechamento do laço for

     textcolor ( LIGHTRED );

     gotoxy ( 29, 23 );

     printf ( "PRESSIONE QUALQUER TECLA" );

     getche ( );

}

/*====================================================================*/

int main ( void ) {

     system ( "title ORDENANDO UM VETOR COM QUICK SORT" );

     Moldura ( 2, 25, 2, 79 );

     textbackground ( WHITE );

     int vet [ TAM ];

     Cria_Vetor ( vet );

    textcolor ( LIGHTBLUE );

    gotoxy ( 25 , 5 );

    printf ( "Vetor gerado desordenado" );

     Imprime_Vetor ( vet );

     Quick_Sort ( vet, 0, TAM );

    textcolor ( LIGHTBLUE );

    gotoxy ( 25 , 5 );

    printf ( "Vetor ordenado por quick sort" );

     Imprime_Vetor ( vet );

    Sleep ( 1800 );

    Informe ( );

    getche ( );

}