Trying to take this literally: `Can anyone know how to make algorithm2 faster than the easiest method?` and `// You need focus on algo2 function.`, with algorithm2 _finding the runner-up among the champion's opponents in a tournament_.  
The straightforward way to find the `k`-max values of an unordered collection is to feed a priority queue of size `k` with its elements.  
The cases with `k` <= 2 are special in not warranting an explicit priority queue: after initialising `k` candidates from the first `k` elements, just compare each of the remaining elements to the current max candidate. If the current element is greater: if looking for the top two elements, keep the max candidate value as the new runner-up, make the current element the max candidate.  
This requires kN+O(1)&nbsp;assignments, worst case, and N-1&nbsp;comparisons.  
The tournament approach to 2-max requires N+ld(N)-O(1) comparisons and N+O(ld(N)) assignments.  
According to this, the number of comparisons _is slightly higher_ for algorithm2, while the number of assignments may be not much more than half that required with the "implicit priority queue". Then again, for "random input", I'd _expect_ the number of assignments in the simplistic approach to grow in the ballpark of _c*lg(N)_ to _c*sqrt(N)_ - strictly lower than _N/2_ for "non-trivial" values of&nbsp;N.  
For any _contemporary sequential machine implementation_, I'd expect simplistic to win hands down against tournament. Design, test, analysis and measurement of parallel renditions left as an exercise…