Problem z pomiarem czasu działania algorytmu

Mam alg sortowania (Quick Sort) i instrukcje mierzącą czas clock_t start = ((1000clock())/CLOCKS_PER_SEC); kod clock_t start = ((1000clock())/CLOCKS_PER_SEC);
Teraz pytanie, dlaczego wciąż pokazuje ze czas działania to 0ms. Dopiero przy 15 tys elementów do posortowania wyświetla 16ms, moim zdaniem to trochę za mało.

#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <time.h>

using namespace std;

const int N = 15000; // Liczebność zbioru.

int d[N];



void Sortuj_szybko(int lewy, int prawy)
{
  int i,j,piwot;

  i = (lewy + prawy) / 2;
  piwot = d[i]; d[i] = d[prawy];
  for(j = i = lewy; i < prawy; i++)
  if(d[i] < piwot)
  {
    swap(d[i], d[j]);
    j++;
  }
  d[prawy] = d[j]; d[j] = piwot;
  if(lewy < j - 1)  Sortuj_szybko(lewy, j - 1);
  if(j + 1 < prawy) Sortuj_szybko(j + 1, prawy);

}

// Program główny
//---------------

int main()
{
  int i,timer;

  srand((unsigned)time(NULL));

  cout << "   Sortowanie szybkie\n"
          
          "Przed sortowaniem:\n\n";



  for(i = 0; i < N; i++) d[i] = rand() % 100;
  for(i = 0; i < N; i++) cout << setw(4) << d[i];
  cout << endl;

// Sortujemy
clock_t start = ((1000*clock())/CLOCKS_PER_SEC);

  Sortuj_szybko(0,N - 1);
      timer=clock()-start;
// Wyświetlamy 

  cout << "Po sortowaniu:\n\n";
  for(i = 0; i < N; i++) cout << setw(4) << d[i];
  cout << endl;
  printf( "Czas wykonywania: %lu ms\n",timer);
    system("PAUSE");
    return EXIT_SUCCESS;
}

Mam jeszcze taką instrukcje

 LONGLONG Frequency, CurrentTime, LastTime;
 double TimeScale;
 QueryPerformanceFrequency( (LARGE_INTEGER*) &Frequency);
 TimeScale = (1.0/Frequency)*1000.0;
 QueryPerformanceCounter( (LARGE_INTEGER*) &LastTime);

kod

QueryPerformanceCounter( (LARGE_INTEGER*) &CurrentTime);
 double milisec = (CurrentTime-LastTime)*TimeScale;
 printf(" %.4fms.",milisec); 

i tutaj przy 5000 pokazuje ok 1.5000 Tyle, że nie wiem w jakiej jednostce to liczy no i czy poprawnie jest to napisane.

clock() nie nadaje się do mierzenia tak krótkich czasu. rozdzielczość tej funkcji to około 16ms, jak chcesz mierzyć nią czas wykonania wielkości kilku ms? albo zamknij sortowanie w pętlę, np. 100 iteracji, i potem zmierz czas wykonania i podziel go przez ilość iteracji (wtedy "zwiększasz" rozdzielczość clock() do 0.16ms), albo użyj funkcji, która służy do pomiaru tak krótkich czasów - QueryPerformanceCounter. QPC ma typowo rozdzielczość 100ns.

[dopisane]
QPC/QPF daje czas w sekundach, * 1000 to czas w ms, więc wynik masz poprawny i wygenerowany zgodnie z regułami feng shui.
zresztą temat jest wałkowany co kilka dni, użyj wyszukiwarki na forum z hasłem QueryPerformanceCounter, znajdziesz kilka dyskusji na ten temat.

Masz pewnie procek 3GHz, czyli taktujący 3 miliardy ticków na sekundę. Jeśli operacje porównania i przypisania kosztują np. 10 ticków to masz 300 milionów takich operacji na sekundę.
Sposób w jaki mierzysz czas ma rozdzielczość około 15ms, czyli procesor w tym czasie wykona 66667 ticków. Zakładając że nasze operacje wykonują się w czasie 10 ticków to mamy nadal 6666 operacji w ciągu tych 15ms. Więc jeśli twój algorytm wykonuje mniej niż te 6666 operacji to czas wykonania będzie 0.
*to jest oczywiście pewna estymacja, bo nie wiem ile twój procesor wymaga ticków do wykonania porównania czy przypisania.

clock_t start = ((1000*clock())/CLOCKS_PER_SEC);

A co to tak w ogóle jest?
edit: w sensie - czemu w clock_t chcesz trzymać ten wynik?

clock_t start = clock();
//...
cout << (clock() - start) / static_cast<double>(CLOCKS_PER_SEC) << "s\n";

A żeby się w tym nie babrać za każdym razem:

        class Timer {
            std::clock_t begin;

        public:
            Timer() : begin(std::clock()) {}

            void start(const std::string& msg = "", std::ostream& out = std::cerr) {
                if (!msg.empty()) {
                    out << msg << '\n';
                }
                begin = std::clock();
            }
            Timer& stop(const std::string& msg = "", std::ostream& out = std::cerr) {
                out << msg
                        << (std::clock() - begin) / static_cast<double>(CLOCKS_PER_SEC)
                        << "s\n";
                return *this;
            }
        };
//...

Timer timer;
timer.start("Zaczynam mierzenie...");
//... costam
timer.stop("Wynik: ");

Rozwiń sobie jeżeli potrzebujesz.

Dzięki wszyskim za konkretne odpowiedzi ale teraz kolejny problem.

 
// Sortowanie Przez Wstawianie

#include <cmath>
#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <time.h>
#include <windows.h>

using namespace std;

const int N = 33333; // Liczebność zbioru.


int main()
{
  int d[N],i,j,x;
  
  cout << " Sortowanie przez wstawianie\n"
          "Przed sortowaniem:\n\n";

// Najpierw wypełniamy tablicę d[] liczbami pseudolosowymi

  
  
  for(i = 0; i <= N; i++) d[i] = i;
  for(i = 0; i <= N; i++) cout << setw(4) << d[i];
  cout << endl;

// Sortujemy

 LONGLONG Frequency, CurrentTime, LastTime;
 double TimeScale;
 QueryPerformanceFrequency( (LARGE_INTEGER*) &Frequency);
 TimeScale = (1.0/Frequency)*1000.0;
 QueryPerformanceCounter( (LARGE_INTEGER*) &LastTime);

  for(j = N - 2; j >= 0; j--)
  {
    x = d[j];
    i = j + 1;
    while((i < N) && (x > d[i]))
    {
      d[i - 1] = d[i];
      i++;
    }
    d[i - 1] = x;
  }
  
QueryPerformanceCounter( (LARGE_INTEGER*) &CurrentTime);
 double milisec = (CurrentTime-LastTime)*TimeScale;
 printf(" %.4fms.",milisec);
// Wyświetlamy wynik sortowania

  cout << "Po sortowaniu:\n\n";
  for(i = 0; i < N; i++) cout << setw(4) << d[i];
  cout << endl;

 printf(" %.4fms.",milisec);
    system("PAUSE");
    return EXIT_SUCCESS;
}

Jak widać sortowanie przez wstawianie dla tablicy posortowanej.
Wychodzi mi tutaj ok 0,384ms
Natomiast dla posortowanej odwrotnie ok 0,385ms

Czy jest to możliwe aby była tak mała różnica? Przecież to jest optymist i pesymistyczna zlozonosc czyli 0(n) i 0(n^2).
Dla tablicy posortowanej odwrotnie mam zmieniony tylko ten fragment:

 
  for(i = N; i >0; i--) d[i] = i;
  for(i = N; i >0; i--) cout << setw(4) << d[i];
  cout << endl;