new question added

Author: arorarahul

README.md

@@ -62,7 +62,9 @@ For eg storing the minimum so far in another stack so that each time when a numb
 ### Heaps (methods that can be applied):
 - A large heap can be delcared and only a small portion of it can always be included in the heap operations.
 - Whenever a heap is built, swapping etc. will be there if elements do not follow the heap property (max or min)
-
+- Sometimes to find largest element in an array, min heap can be made, for few first elements, and each
+time comparisons can be done with remaining element to eliminate the minimum elements.
+- Methods where min and max heap can be applied BST can also be used (depends on question) 
 
 # Topic0: Programming Questions
 
@@ -183,6 +185,7 @@ For eg storing the minimum so far in another stack so that each time when a numb
 - [Write a program for heap sort](/heaps/question3.c)
 - [Find a max element in a min-heap](/heaps/question4.c)
 - [Build a min-heap and write algo to delete an arbitrary element](/heaps/question5.c)
+- [Find k largest elements from an array](/heaps/question6.c)
 
 ## Some important concepts to solve algos better
 
@@ -218,6 +221,8 @@ For eg storing the minimum so far in another stack so that each time when a numb
 - There is an O(n) time algo to convert an element into a heap. So no need to sort as sorting take O(nlogn)
 - Recursion adds to the space complexity as well as time complexity.
 - In a max heap, finding min, deleting random element or searching an element will take O(n) time because here max heap is as good as an array.
+- For Binary Search tree implementation using an array, space complexity is O(2^n), but using linked list, it
+is O(n)
 
 # Topic1: Introduction
 

heaps/question6.c

@@ -0,0 +1,38 @@
+/*
+Find k largest elements from an array
+
+METHOD1:
+Find max element from the array. Now output that element and replace it with the last element and decrease the
+size of the array. Again find the max element and repeat the steps above. Keep doing it k times.
+Time complexity: O(kn) //assuming k is less than n
+Space complexity: O(1)
+
+METHOD2:
+Sort the array and display the last k elements.
+Time complexity: O(nlogn)
+Space complexity: O(1)
+
+METHOD3:
+Build a max heap from the given array. Delete max k times and print
+Time complexity: O(n) + O(klogn) //n for building the heap klogn as for deleting max k times. If k is almost 
+equal to n here, time complexity will become O(nlogn), if small then O(n)
+Space complexity: O(1)
+
+METHOD4:
+Create a binary search tree from the given elements. Find the maximum each time from the BST and remove it 
+fromt the tree and repeat it k times.
+Time complexity: O(n^2) + O(kn) //n^2 to make the binary search tree as in worst case the tree can be skewed.
+n to search for each element. Since it is done k times O(kn)
+Space complexity: O(2^n) OR O(n) //BST using array or linked list
+
+METHOD5:
+Make a min heap using the first k elements in the array and assume that they are the largest k elements in the
+array. Now from k+1th element start comparing each n-k remaining elements with the root of the heap and replace
+if the root of the heap is smaller than that element and apply heapify again.
+Repeat these steps for all n-k remaining elements and in the end the min-heap will have k largest elements 
+from the array
+Time complexity: O(k) + O((n-k)logk) //k for building the heap having k elements and (n-k)logk elements because
+that many time minheapify will be called
+Space complexity: O(1) //min heap and max heap do not require additional data structure. Same array can
+be manipulated unless mentioned in the question
+*/

nextquestions.md

@@ -41,4 +41,7 @@ TODO:
 - question 8, 9 implementation for stacks and queues to be done
 - Program to find then the stock should be sold in order to gain max profit
 - insert key in heap question2 to be done
-- building min/max heap for duplicate elements
+- building min/max heap for duplicate elements
+- Do BST method in question 6 for heaps
+
+