Q:

Совершенно не могу понять, где может быть RunTime Error

Нужно написать аналог ls -lR
Подаются в качестве первого аргумента имя директории, и нужно рекурсивно вывести содержимое директории в виде (отсортировано) :
АТТРИБУТЫ КОЛ_ВО_ССЫЛОК ВЛАДЕЛЕЦ ГРУППА РАЗМЕР ИМЯ (на С)
Вроде бы написала, но никак не могу понять где может быть RunTime Error. Помогите пожалуйста, уже совсем отчаялась. Вроде бы и массивы сделала без выделения памяти, все равно все тот же RunTime Error
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <grp.h>
#include <pwd.h>
#include <unistd.h>

int comp (const void *i, const void *j) {
    return strcmp(*(const char**)i, *(const char**)j);
}

void fill(char *array, struct stat fStat){
    if(S_ISDIR(fStat.st_mode))
        array[0] = 'd';
    else if(S_ISBLK(fStat.st_mode))
        array[0] = 'b';
    else if(S_ISLNK(fStat.st_mode))
        array[0] = 'l';
    else if(S_ISCHR(fStat.st_mode))
        array[0] = 'c';
    else if(S_ISFIFO(fStat.st_mode))
        array[0] = 'p';

    if (fStat.st_mode & S_IRUSR)
        array[1] = 'r';
    if (fStat.st_mode & S_IWUSR)
        array[2] = 'w';
    if (fStat.st_mode & S_IXUSR)
        array[3] = 'x';
    if (fStat.st_mode & S_IWGRP)
        array[4] = 'w';
    if (fStat.st_mode & S_IRGRP)
        array[5] = 'r';
    if (fStat.st_mode & S_IXGRP)
        array[6] = 'x';
    if (fStat.st_mode & S_IROTH)
        array[7] = 'r';
    if (fStat.st_mode & S_IWOTH)
        array[8] = 'w';
    if(fStat.st_mode & S_IXOTH)
        array[9] = 'x';
}

int countF(DIR *dir){
    int count = 0;
    while((readdir(dir)) != NULL){
        ++count;
    }
    rewinddir(dir);
    return count;
}
void recursion(char *directoryName){
    struct stat f;
    if(lstat(directoryName, &f) != 0){
        perror("Error");
        exit(0);
    }
    if(!S_ISDIR(f.st_mode)){
        struct passwd *p = getpwuid(f.st_uid);
        struct group *g = getgrgid(f.st_gid);
        char array [12];
        int l = 0;
        for (l = 0; l < 9; ++l) {
            array[l] = '-';
        }
        fill(array, f);
        printf("%s %d ", array, f.st_nlink);
        if (p != NULL && g != NULL) {
            printf("%s %s", p->pw_name, g->gr_name);
        } else if (p == NULL && g != NULL) {
            printf("%d %s", f.st_uid, g->gr_name);
        } else if (p != NULL && g == NULL) {
            printf("%s %d", p->pw_name, f.st_gid);
        } else {
            printf("%d %d", f.st_uid, f.st_gid);
        }

        printf("%lld %s", f.st_size, directoryName);

        if (S_ISLNK(f.st_mode)) {
            char link[1000000];
            if (readlink(directoryName, link, 1000000) == -1) {
                exit(1);
            } else {
                printf(" -> %s", link);
            }
        }
        printf("\n");
    }
    else {
        DIR *dir = opendir(directoryName);
        if (dir == NULL) {
            perror("Error");
            closedir(dir);
            return;
        }
        int countOfFiles = countF(dir);

        if (directoryName[strlen(directoryName) - 1] != '/') {
            directoryName = (char *) realloc(directoryName, strlen(directoryName) + 2);
            strcat(directoryName, "/");
        }
        char arrayOfFiles[countOfFiles][10000000];
        char **arrayOfDirectories =  malloc(1000000 * sizeof(char*));
        int j, k;
        for (j = 0; j < countOfFiles; ++j) {
            if (arrayOfFiles[j] == NULL) {
                perror("");
                free(arrayOfFiles[j]);
                exit(0);
            }

            for (k = 0; k < strlen(readdir(dir)->d_name); ++k) {
                arrayOfFiles[j][k] = readdir(dir)->d_name[k];
            }
        }
        qsort(arrayOfFiles, countOfFiles, sizeof(char *), comp);

        int countOfDirectories = 0;
        for (k = 0; k < countOfFiles; ++k) {
            if (!(strlen(arrayOfFiles[k]) == 1 && arrayOfFiles[k][0] == '.') &&
                !(strlen(arrayOfFiles[k]) == 2 && arrayOfFiles[k][0] == '.' && arrayOfFiles[k][1] == '.')) {
                struct stat Stat;
                if (lstat(directoryName, &Stat) != 0) {
                    perror("");
                    exit(1);
                }
                if (S_ISDIR(Stat.st_mode)) {
                    arrayOfDirectories[countOfDirectories] = directoryName;
                    countOfDirectories++;
                }

                struct passwd *p = getpwuid(Stat.st_uid);
                struct group *g = getgrgid(Stat.st_gid);
                char array[12];
                int l = 0;
                for (l = 0; l < 10; ++l) {
                    array[l] = '-';
                }

                fill(array, Stat);
                printf("%s %d ", array, f.st_nlink);
                if (p != NULL && g != NULL) {
                    printf("%s %s", p->pw_name, g->gr_name);
                } else if (p == NULL && g != NULL) {
                    printf("%d %s", f.st_uid, g->gr_name);
                } else if (p != NULL && g == NULL) {
                    printf("%s %d", p->pw_name, f.st_gid);
                } else {
                    printf("%d %d", f.st_uid, f.st_gid);
                }

                printf("%lld %s", Stat.st_size, arrayOfFiles[k]);

                if (S_ISLNK(Stat.st_mode)) {
                    char link[1000000];
                    if (readlink(directoryName, link, 1000000) == -1) {
                        exit(1);
                    } else {
                        printf(" -> %s", link);
                    }
                }
                printf("\n");
            }
        }
        printf("\n");
        for (k = 0; k < countOfDirectories; ++k) {
            recursion(arrayOfDirectories[k]);
        }

        for (j = 0; j < countOfDirectories; ++k) {
            free(arrayOfDirectories);
        }
        free(directoryName);
        free(arrayOfDirectories);
        closedir(dir);
    }
}
int main(int argc, char **argv) {
    recursion(argv[1]);
    return 0;
}

A:

Рекурсивная функция содержит внутри локальные массивы 
char link[1000000];

и даже 
сhar arrayOfFiles[countOfFiles][10000000];

Такое запросто может вылетать по переполнению стека. Может вам следует умерить аппетиты? 
Проверка
for (j = 0; j < countOfFiles; ++j) {
  if (arrayOfFiles[j] == NULL) 

является бессмысленной. arrayOfFiles[j] никак не может быть NULL.
free(arrayOfFiles[j]); - это как это?
Вызов
qsort(arrayOfFiles, countOfFiles, sizeof(char *), comp);

для такого arrayOfFiles является некорректным и бессмысленным.
directoryName = (char *) realloc(directoryName, strlen(directoryName) + 2);

и далее
free(directoryName);

Но изначально directoryName - это argv[1]. Кто вам разрешил применять realloc или free к argv[1]?
arrayOfDirectories[countOfDirectories] = directoryName;??? В чем смысл цикла, который на каждой итерации ставит очередную arrayOfDirectories[countOfDirectories] указывать на один тот же буфер directoryName? В чем вообще смысл делать if (lstat(directoryName, &Stat) != 0) { для одного и того же directoryName на каждой итерации цикла?
Это еще что за бессмыслица?
for (j = 0; j < countOfDirectories; ++k) {
    free(arrayOfDirectories);
}
free(arrayOfDirectories);

