CareerCup

Do not create a heap
The thing that must be kept in mind is that the worst case complexity does not exceed 4n. Because, by traversing the array 4 times, it is possible to solve the problem. So, a heap would increase the complexity as the average complexity would be more than 4n in most of the implementations.
We can just maintain a length 4 array, in which the average complexity would be 2n.

use a heap
* build a min heap of 4 elements
* iterate over the remaining elements
* if the remaining element is greater than the minimum element of the heap
----- delete the minimum element
----- insert the new element
at the end u will be left with the 4 greatest element in the heap

- Create a min heap of size 4
- Insert the first 4 elements
- for each of the remaining elements, compare with the 'min' element, if the element is greater than the min element, remove the 'min' element, and insert the current element

Use the median of medians algorithm to find the kth smallest / greatest element in an array. The time complexity is O(n)
//en.wikipedia.org/wiki/Selection_algorithm

Just iterate through the elements and store them in a std::map. std::map doesn't store duplicates, so you don't need to worry about that. After you've stored the whole array, the 4 largest numbers are myMap[myMap.size()-1], myMap[myMap.size()-2], myMap[myMap.size()-3], myMap[myMap.size()-4].
This will take O(n) time.

string = "2,3,-2,-1,10,1,2,3,4,5,6,7,8,9";
     numbers = string.split(",");
     int[] max = new int[4];
     for (int i = 0; i <= 3; i++) {
    	 max[i] = Integer.valueOf(numbers[i]);
     }
     Arrays.sort(max);
     for (String val_tmp : numbers) {
    	 int val = Integer.valueOf(val_tmp);
    	 if(val > max[0]) {
    		 max[0] = val;
    	 }
    	 Arrays.sort(max); 
     }

i think by using bubble sort for 4 iterations we can get the four maximum elements . total 4n-10 means order of n .. we can do this

Just iterate through the array and store the numbers in a std::map. std::map doesn't store duplicates so you don't have to worry about that. After storing, the 4 largest numbers are: myMap[myMap.size() -1], myMap[myMap.size() -2], myMap[myMap.size() -3], myMap[myMap.size() -4].

IF we sort elements in O(n ln n ) and find 4 elements in O(const) time

Bubble sort takes O(n square)

But in the first iteration in bubble sort, the largest element will be found.
In the next iteration, the second largest element will be found.

So, using this technique four times gives us the four largest numbers

Why can't we use priority queue and take out the first or last four.

use insertion sort..

Use SSE(AVX) to compare 4(8) numbers with min. Do not pass array 4 times because memory bus become a limitation.
Or with reasonable assumptions about data distribution find min in a block by comparing 4(8) int's groups. When compare min with 4 el array. Size of block could be variable based on size passed.

Use SSE(AVX) to compare 4(8) numbers with min. Do not pass array 4 times because memory bus become a limitation.
Or with reasonable assumptions about data distribution find min in a block by comparing 4(8) int's groups. When compare min with 4 el array. Size of block could be variable based on size passed.

we need to first sort the array using :
Arrays.sort(arr);
and then iterate from length to length - 4

for(int i = arr.length -1; i>= arr.length - 5; i--){
System.out.println(arr[i]);
}