In this case it is not clear the author intended to claim their code has quicksort properties. The "why don't they" question at the bottom could be read as "Or is it quick-sort?" Hey I'm being generous because reading just the slides is bound to miss subtext.
(I agree that this implementation is neat. I think it's a great way to explain sorting.)
(naive qsort is O(n^2) in the worst case (with pivot selection it is Theta(nlogn), though,) but the functional-linked-list-sort is O(n^2) in all cases... :))
Write this algorithm in an imperative language and it'll pretty clear that this is best/expected case O(n^2).
Suppose the length of (qsort (filter (<x) xs)) is k. Then the time to do the two appends in (qsort (filter (<x) xs)) ++ [x] ++ (qsort (filter (>=x) xs)) is k + (k+1), which is linear in k.
At the same time any quicksort (even an in-place one) will scan through the entire array once in order to partition it, which also takes linear time. (It will take time proportional to the length of the entire array, not just the first half.) The extra work from the appends only changes the constant factors, not the asymptotics.
> Why don’t they teach it like that in the algorithms course?)
I'm sure they do sometimes. However, it is incorrect because quick-sort is an O(nlogn) in-place sort. This is a best-case O(n^2) sort (due to the linked-list appending) and is not in-place. If you got taught this as quick-sort ask for a refund... ;)
---
Honestly, there's isn't anything very interesting in these slides assuming you already know basic functional programming. The dissing of Lisp was odd given the functionality of Haskell that was used was approximately the intersection of Haskell and whichever-Lisp, plus basic static typing (which you can get in various Lisps as well: https://docs.racket-lang.org/ts-guide/ )