Code:
#include <stdio.h>

int *niz;
long int n; // broj elemenata, long za svaki slucaj, treba nam 32 bita za 30 miliona

void ucitajNizIzFajla(char* imeFajla)
{
     FILE* in;
     int i;
     in = fopen(imeFajla, "r");
     fscanf(in, "%d", &n); // ucitava broj elemenata
     // ako je broj elemenata fiksan, onda samo stavi
     // n = brojElemenata umesto ovog

     niz = (int*)malloc(sizeof(int)*n); // alocira niz od n brojeva

     for(i=0; i<n; i++)
     {
          fscanf(in, "%d", &(niz[i])); // ucitava i-ti broj iz fajla
     }
}

Code:
NIZOVI* niz;
void izFajla()
{
     ifstream infile("sort.txt");
     niz = new NIZOVI[30000000];

     for(long int i=0; i<30000000; i++)
     {
          infile >> niz[i].x;
          cout << niz[i].x;
     }
}

Code:

#include <stdio.h>
#include <stdlib.h>
#include <sys\timeb.h>
#include <conio.h>

#define MaxN 10000000

long a [MaxN], temp [MaxN], time1, time2, n, i, pos;
float tim;

void swap (long x, long y)
{
    long pom;
    pom = temp [x];
    temp [x] = temp [y];
    temp [y] = pom;
}

void swap1 (long x, long y)
{
    long pom;
    pom = a [x];
    a [x] = a [y];
    a [y] = pom;
}

void q_sort (long l, long r)
{
    long i = l, j = r, mid = temp [(l + r) >> 1];
    do
    {
        while (temp [i] < mid)
            i++;
        while (temp [j] > mid)
            j--;
        if (i <= j)
        {
            swap (i, j);
            i++;
            j--;
        }
    }
    while (i <= j);
    if (l < j)
        q_sort (l, j);
    if (i < r)
        q_sort (i, r);
}

void QuickSort ()
{
    q_sort (1, n);
//    for (i = 0; i < n; i++)
//        printf ("%-3d", temp [i + 1]);
//    printf ("\n");
}

void ubaci (long x)
{
    long child, parent;
    pos++;
    temp [pos] = a [x];
    child = pos;
    while (1)
    {
        parent = child >> 1;
        if (parent == 0 || temp [parent] <= temp [child])
            break;
        swap (parent, child);
        child = parent;
    }
}

void izbacimin ()
{
    long parent, child;
    temp [1] = temp [pos];
    pos--;
    parent = 1;
    if (pos > 1)
    {
        child = 2;
        while (child <= pos)
        {
            if (child != pos && temp [child] > temp [child + 1])
                child++;
            if (temp [child] < temp [parent])
            {
                swap (parent, child);
                parent = child;
                child <<= 1;
            }
            else
                child = pos + 1;
        }
    }
}

void HeapSort ()
{
    pos = 0;
    for (i = 0; i < n; i++)
        ubaci (i);
    for (i = 0; i < n; i++)
    {
//        printf ("%-3d", temp [1]);
        izbacimin ();
    }
//    printf ("\n");
}

void m_sort (long l, long r)
{
    long br1, br2, br3, i, mid;
    if (l == r)
        return;
    if (r - l == 1)
    {
        if (a [l] > a [r])
            swap1 (l, r);
        return;
    }
    mid = (l + r) >> 1;
    m_sort (l, mid);
    m_sort (mid + 1, r);
    br1 = l;
    br2 = mid + 1;
    br3 = l - 1;
    while (!(br1 > mid && br2 > r))
    {
        br3++;
        if (br1 > mid)
        {
            temp [br3] = a [br2];
            br2++;
            continue;
        }
        if (br2 > r)
        {
            temp [br3] = a [br1];
            br1++;
            continue;
        }
        if (a [br1] < a [br2])
        {
            temp [br3] = a [br1];
            br1++;
        }
        else
        {
            temp [br3] = a [br2];
            br2++;
        }
    }
    for (i = l; i <= r; i++)
        a [i] = temp [i];
}

void MergeSort ()
{
    m_sort (0, n - 1);
//    for (i = 0; i < n; i++)
//        printf ("%-3d", a [i]);
//    printf ("\n");
}

void main ()
{
    clrscr ();
    struct timeb t;
    n = MaxN - 5;
//    randomize ();
    for (i = 0; i < n; i++)
    {
        a [i] = rand ();
//        printf ("%-3d", a [i]);
    }
//    printf ("\n\n");

    for (i = 0; i < n; i++)
        temp [i + 1] = a [i];


    ftime (&t);
    time1 = (t.time % 100) * 1000 + t.millitm;

    QuickSort ();

    ftime (&t);
    time2 = (t.time % 100) * 1000 + t.millitm;
    tim = (time2 - time1);
    tim /= 1000;
    printf ("QuickSort: %.2f\n\n", tim);

    ftime (&t);
    time1 = (t.time % 100) * 1000 + t.millitm;

    HeapSort ();

    ftime (&t);
    time2 = (t.time % 100) * 1000 + t.millitm;
    tim = (time2 - time1);
    tim /= 1000;
    printf ("HeapSort: %.2f\n\n", tim);

    ftime (&t);
    time1 = (t.time % 100) * 1000 + t.millitm;

    MergeSort ();

    ftime (&t);
    time2 = (t.time % 100) * 1000 + t.millitm;
    tim = (time2 - time1);
    tim /= 1000;
    printf ("MergeSort: %.2f\n", tim);
    exit (0);
}