find the kth largest element in a list and find the first k largest elements in a list

Problem 1: Given an unordered  list, find the kth largest element in this list.

Solution 1

  sort this list and you can immediately get the kth largest element.

  The time-complexity is O(NlogN).

 

Solution 2

   pythonic pseudocode:  

     find_kth(list, k):

        create a  container H with a fixed size k.

        Fullfill H with the first k elements in the specified list.

        for e in list[k: N -1]:

          min  = smallest(H)

          if e is larger than min:

             delete min from H

             add e into H

        return H[k - 1]

 

  Time-complexity: O(kN).

 

  A better choice of implemention of  the container in above code is Heap, which is easy to find the minimum element, delete it and add a new element.

 

 

Solution 3: quick select alogrithm

  Quick select alogrithm is very similar to quick sort.

  Pythonic pseudocode:

    quick_select(list, k):

        pivot = list[0].

        split list into two parts(smaller and larger), one contains elements equal to or smaller than pivot, the other one contains elements  larger than pivot.

        if len(larger) == k:

          return larger[k-1]

        elif len(larger) > k:

          return quick_select(larger, k)

        else:

          return quick_select(smaller, k - len(larger)

 

  Time Complexity: O(N)

 

  Implementions:

    erlang code:

       kth([], _) -> error; kth([H], 1) -> H; kth([H|L], K) -> {L1, L2} = lists:partition(fun(X) -> X > H end, L), Len1 = length(L1), if Len1 + 1 == K -> H; Len1 + 1 > K -> kth(L1, K); Len1 + 1 < K -> kth(L2, K - Len1-1) end.

 

   java code:

       public static Integer kth(Integer[] list, int k, int begin, int end){ int i = begin; int j = end; Integer pivot = list[begin]; while(j > i){ while(j > i && list[j] < pivot){ j--; } if(j > i){ list[i++] = list[j]; } while(j > i && list[i] >= pivot){ i++; } if(j > i){ list[j--] = list[i]; } } list[i] = pivot; if( i+1 == k){ return list[i]; }else if( i + 1 < k){ return kth(list, k, i + 1, end); } else { return kth(list, k, begin, i - 1); } }

 

  

 

Problem 2: Given an unordered  list, find the first k largest elements in this list.

 

 

   This problem is similar to the first problem. Actually, if we  examine the three solutions of the first problem, we can see that we alread get the first k largest elements for finding the kth largest element . So we have solved this problem.