Finding an algorithm to return the $\log n$ largest element in an array
A possibility (don't think it's the simplest way, though) is:

Transform the array into a max-heap;
find (without extracting) the $\log n$ largests elements in the heap.

The first step can be done in $O(n)$. For the second step, let's give a little bit details:

The largest element is found among one element (it's the root);
the second largest must be found among two elements (the two children of the root);
in general, the $k$-th largest element must be found among $k$ elements, because each time you select an element to be the largest, you remove it from the candidates and add its two children.

That means that after having found the $k$ largest elements, finding the $k+1$-th is done by searching the maximum value among $k+1$, so it is done in $O(k)$. Since we want to find at most $\log n$ elements, the total search takes $O((\log n)^2)$ time, and with the property you proved, it is $O(n)$.
That means that the total complexity of the algorithm is $O(n)$ which is obviously optimal since you need to browse all elements of the array.
Edit: Actually, I realize (that confirms what I initially said) that there is a simpler way to do it:
Use a quickselect algorithm to find the $\log n$-th largest element (no plural here) of the array (this is done in $O(n)$). By doing so in place, the $\log n$ largest elements will be placed in consecutive positions at the end of the array. You can then sort those $\log n$ elements in time complexity $O(\log n \log \log n) \subset O((\log n)^2) \subset O(n)$.