formatted code

Author: PallavJain01

Sort Array 0-1-2.md

@@ -1,81 +1,91 @@
 ### [Back2Home](https://github.com/CodingWallah/Arrays-DSA-Coding-Questions) | [Go2Video](#)
+
+
+
+### Solution 1 `Best`
+#### Time Complexity: `O(n)`
+#### Space Complexity: `O(1)`
 ```java
 
-//Best Solution 1 || Time = O(n) , Space = O(1)
 class Solution {
-  public void sortColors(int[] nums) {
-  int start = 0;
-  int end = nums.length - 1;
-  int ptr = 0, temp = 0;
- while (ptr <= end) {
-  switch (nums[ptr]) {
-  case 0: {
-  temp = nums[start];
-  nums[start] = nums[ptr];
-  nums[ptr] = temp;
-  start++;
-  ptr++;
-  break;
-  }
-  case 1:
-  ptr++;
-  break;
-  case 2: {
-  temp = nums[ptr];
-  nums[ptr] = nums[end];
-  nums[end] = temp;
-  end--;
-  break; 
-  }
-  }
+ public void sortColors(int[] nums) {
+ int start = 0;
+ int end = nums.length - 1;
+ int ptr = 0, temp = 0;
+
+ while (ptr <= end) {
+ switch (nums[ptr]) {
+ case 0: {
+ temp = nums[start];
+ nums[start] = nums[ptr];
+ nums[ptr] = temp;
+ start++;
+ ptr++;
+ break;
+ }
+ case 1: {
+ ptr++;
+ break;
+ }
+ case 2: {
+ temp = nums[ptr];
+ nums[ptr] = nums[end];
+ nums[end] = temp;
+ end--;
+ break; 
  }
+ }
  }
+ }
 }
-
 ```
 
+##
+
+### Solution 2
+#### Time Complexity: `O(n)`
+#### Space Complexity: `O(1)`
 ```java
 
-//Solution2 - time complexity = O(n) | space = O(1)
 class Solution {
- public void sortColors(int[] nums) {
- int i=0, cnt0 = 0, cnt1 = 0, cnt2 = 0;
- for (i = 0; i < nums.length; i++) {
- if(nums[i]==0) 
- cnt0++;
- else if(nums[i]==1) 
- cnt1++;
- else if(nums[i]==2) 
- cnt2++;
- }
- 
- i = 0;
- 
- while (cnt0 > 0) {
- nums[i++] = 0;
- cnt0--;
- }
- 
- while (cnt1 > 0) {
- nums[i++] = 1;
- cnt1--;
- }
- 
- while (cnt2 > 0) {
- nums[i++] = 2;
- cnt2--;
- }
+ public void sortColors(int[] nums) {
+ int i = 0, count0 = 0, count1 = 0, count2 = 0;
+ for (i = 0; i < nums.length; i++) {
+ if (nums[i] == 0)
+ count0++;
+ else if (nums[i] == 1)
+ count1++;
+ else if (nums[i] == 2)
+ count2++;
+ }
+
+ i = 0;
+
+ while (count0 > 0) {
+ nums[i++] = 0;
+ count0--;
+ }
+
+ while (count1 > 0) {
+ nums[i++] = 1;
+ count1--;
  }
+
+ while (count2 > 0) {
+ nums[i++] = 2;
+ count2--;
+ }
+ }
 }
 
 ```
+### Solution 3 `Not Recommended`
+#### Time Complexity: `O(n*logn)`
 
 ```java
-
-//sol3 || Time = O(nlogn)
- class Solution {
- public void sortColors(int[] nums) {
- Arrays.sort(nums);
- }
+class Solution {
+ public void sortColors(int[] nums) {
+ Arrays.sort(nums);
+ }
 }
 ```

kth-largest-smallest.md

@@ -1,84 +1,86 @@
 ### [Back2Home](https://github.com/CodingWallah/Arrays-DSA-Coding-Questions) | [Go2Video](#)
 
-1) min heap = uses for largest ?
+##
+
+#### `When` max Heaps and when min Heaps and `why`?
 
+1) min heap = uses for largest ?
 2) max heap = uses for smallest ?
 
-### WHEN max and when min HEAPS and WHY ?
+> #### :exclamation: k is small = min; | k is large = MAX;
 
- Note- k is small = min; | k is large = MAX;
-```java
+##
 
-//sol1 = using sorting or trick
-// Time complexity = O(NlogN)
+### Solution 1 : Using Sorting
+#### Time Complexity: `O(n*logn)`
+```java
 class Solution {
  public int findKthLargest(int[] nums, int k) {
  Arrays.sort(nums);
  return nums[nums.length-k];
  }
 }
-
 ```
 
-```java
+##
 
-//MIN HEAP APPROACH = Best Solution O(N + NlogK) time complexity
+### Solution 2: Min Heap Approach 
+#### Time Complexity: `O(n + n*logk)`
+`Best Solution`
+```java
 PriorityQueue<Integer> minheap = new PriorityQueue<Integer>();
- for(int i=0;i<k;i++)
- minheap.add(nums[i]);
- 
- 
- for(int i=k;i<nums.length;i++){
- if(nums[i]>minheap.peek()){
- minheap.poll();
- minheap.add(nums[i]);
- }
- }
+ for(int i=0;i<k;i++)
+ minheap.add(nums[i]);
+ 
+ for(int i=k;i<nums.length;i++){
+ if(nums[i]>minheap.peek()){
+ minheap.poll();
+ minheap.add(nums[i]);
+ }
+ }
 return minheap.peek();
 ```
-```java
 
-//MIN HEAP EASY & CONCISE IMPLEMENTATION
-PriorityQueue<Integer> pq = new PriorityQueue<Integer>(); 
- for(int i : nums){
- pq.add(i);
- if(pq.size()>k){
- pq.remove();
- }
- }
- 
- return pq.remove();
+`Concise Implementation`
 
+```java
+PriorityQueue<Integer> pq = new PriorityQueue<Integer>(); 
+ for(int i : nums){
+ pq.add(i);
+ if(pq.size()>k){
+ pq.remove();
+ }
+ }
+return pq.remove();
 ```
 
+## 
 
+### Solution 3: Max Heap Approach
+#### Time Complexity: `O(n + n*logk)`
+`Best Solution`
 ```java
-//MAX HEAP APPROACH = Best Solution O(N + NlogK) time complexity
 PriorityQueue<Integer> maxHeap = new PriorityQueue<Integer>(Collections.reverseOrder()); 
- for(int i=0;i<nums.length-k+1;i++)
- maxHeap.add(nums[i]);
- 
- for(int i=nums.length-k+1;i<nums.length;i++){
- if(nums[i]<maxHeap.peek()){
- maxHeap.poll();
- maxHeap.add(nums[i]);
- }
- }
-
- return maxHeap.peek(); 
+ for(int i=0;i<nums.length-k+1;i++)
+ maxHeap.add(nums[i]);
+ 
+ for(int i=nums.length-k+1;i<nums.length;i++){
+ if(nums[i]<maxHeap.peek()){
+ maxHeap.poll();
+ maxHeap.add(nums[i]);
  }
- 
+ }
+return maxHeap.peek();
 ```
 
+`Consice Implementation`
 ```java
-//MAX HEAP EASY & CONCISE IMPLEMENTATION
 PriorityQueue<Integer> pq = new PriorityQueue<Integer>(Collections.reverseOrder()); 
- for(int i : nums){
- pq.add(i);
- 
- for(int i=1;i<k;i++)
- pq.poll();
- 
- return pq.peek(); 
- 
+ for(int i : nums){
+ pq.add(i);
+ 
+ for(int i=1;i<k;i++)
+ pq.poll();
+ 
+return pq.peek(); 
 ```