Q: How do different languages implement sorting in their standard libraries? From what I have (briefly) read, Java and Python both look like they make use of timsort in their standard libaries, while the sorting method in C's stdlib is called qsort because it once was quicksort.
What algorithm do typical languages have implemented in their standard libraries today, and why did they choose that algorithm? Also, did C deviate from quicksort?
I know this question lacks an "actual problem(s) that [I] face" and may seem open ended to some, but knowing how/why certain algorithms are chosen as standard seems pretty useful but relatively untaught. I also feel as though an in depth answer addressing concerns that are language specific (data types?) and machine specific (cache hits?) would provide more insight to how different languages and algorithms work than uni cares to explain.

A: In musl, we use Smooth Sort. Conceptually it's a variant of heap sort (and likewise in-place and O(n log n) time), but it has the nice property that the worst-case performance approaches O(n) for already-sorted or near-sorted input. I'm not convinced it's the best possible choice, but it appears very difficult to do better with an in-place algorithm with O(n log n) worst-case.
Being a little-known invention of Dijkstra's also makes it kind of cool. :-)

A: C does not specificy the algorithm to be used by qsort.
On current glibc (2.17) qsort allocates memory (using malloc or alloca if memory required is really small) and uses merge sort algorithm. If memory requirements are too high or if malloc fails it uses quicksort algorithm.

A: My machine's C library provides qsort, heapsort, and mergesort, saying in the man page:

The qsort() and qsort_r() functions are an implementation of C.A.R.  Hoare's "quicksort" algorithm, a variant of partition-exchange sorting; in particular, see D.E.
       Knuth's Algorithm Q.  Quicksort takes O(n lg n) average time.  This implementation uses median selection to avoid its O(n2) worst-case behavior.
The heapsort() function is an implementation of J.W.J. William's "heapsort" algorithm, a variant of selection sorting; in particular, see D.E. Knuth's Algorithm H.
       Heapsort takes O(n lg n) worst-case time.  Its only advantage over qsort() is that it uses almost no additional memory; while qsort() does not allocate memory, it is
       implemented using recursion.
The function mergesort() requires additional memory of size nel * width bytes; it should be used only when space is not at a premium.  The mergesort() function is optimized for data with pre-existing order; its worst case time is O(n lg n); its best case is O(n).
Normally, qsort() is faster than mergesort() which is faster than heapsort().  Memory availability and pre-existing order in the data can make this untrue.

There are plenty of open source C libraries for you to look at if you want to see specific details of the implementation.
As far as 'why did system X choose algorithm Y', that's a pretty tough question to answer meaningfully - if you're not lucky enough to find a rationale in the documentation, you'd have to ask the designers directly.

A: I did a quick scan in the C11 standard about qsort() and I couldn't find any reference about how qsort() should be implemented 
and the expected time/space complexity of the algorithm. All it has to say was about certain conditions about the comparator 
function. 
What that means is an implementation can choose any comparator based algorithm that fits with qsort(). For example, an implementation can choose to use a naive algorithm such as bubble sort to implement qsort() which is not as efficient as the real quick sort. Bottom line is that it's upto the implementation to decide on the actual algorithm.
