通过深度优先或宽度优先发现文件夹树

Question

I had to find the paths to the "deepest" folders in a folder. For this I implemented two algorithms, and one is way faster than the other. Does anyone know why ? I suppose this has some link with the hard-disk hardware but I'd like to understand. Here is the fast one :

    private function getHostAux($path) {
        $matches = array();
        $folder = rtrim($path, DIRECTORY_SEPARATOR);

        $moreFolders = glob($folder.DIRECTORY_SEPARATOR.'*', GLOB_ONLYDIR);
        if (count($moreFolders) == 0) {
           $matches[] = $folder;
        } else {
            foreach ($moreFolders as $fd) {
                $arr = $this->getHostAux($fd);
                $matches = array_merge($matches, $arr);
            }
        }
        return $matches;
    }

And here is the slow-one :

    /**
     * Breadth-first function using glob
     */
private function getHostAux($path) {
    $matches = array();
    $folders = array(rtrim($path, DIRECTORY_SEPARATOR));
    $i = 0;
    while($folder = array_shift($folders)) {
        $moreFolders = glob($folder.DIRECTORY_SEPARATOR.'*', GLOB_ONLYDIR);
        if (count($moreFolders == 0)) {
            $matches[$i] = $folder;
        }
        $folders = array_merge($folders, $moreFolders);
        $i++;
    }
    return $matches;
}

Thanks !

Answer 1

You haven't provided additional informations that might be crucial for understanding these "timings" which you observed. (I intentionally wrote the quotes since you haven't specified what "slow" and "fast" mean and how exactly did you measure it.)

Assuming that the supplied informations are true and that the speedup for the first method is greater than a couple of percent and you've tested it on directories of various sizes and depth...

First I would like to comment on the supplied answers:

• I wouldn't be so sure about your answer. First I think you mean "kernel handles ". But this is not true since glob doesn't open handles. How did you come up with this answer?
• Both versions have the same total iteration count.

And add something from myself:

• I would suspect array_shift() may cause the slowdown because it reindexes the whole array each time you call it.
• The order in which you glob may matter depending on the underlying OS and file system.
• You have a bug (probably) in your code. You increment $i after every glob and not after adding an element to the $matches array. That causes that the $matches array is sparse which may cause the merging, shifting or even the adding process to be slower. I don't know exactly if that's the case with PHP but I know several languages in which arrays have these properties which are sometimes hard to keep in mind while coding. I would recommend fixing this, timing the code again and seeing if that makes any difference.

Answer 2

I think that your first algorithm with recursion does less iterations than the second one. Try to watch how many iterations each algorithm does using auxilary variables.