# Median of two sorted array

Before going any further, let’s understand what is a median? “Median” is “middle” value in list of numbers. To find median, input should be sorted from smallest to largest. If input is not sorted, then we have to first sort and them return middle of that list. Question arises is what if number of elements in list are even? In that case, median is average of two middle elements. Ask of this problem is to find median of two sorted arrays.
For example :

Before going into the post, find a pen and paper and try to work out example. And as I tell in our posts, come up with a method to solve this considering, you have all the time and resources to solve this problem. I mean think of most brute force solution.
Let’s simplify the question first and then work it upwards. If question was to find median of one sorted array, how would you solved it?
If array has odd number of elements in it, return `A[mid]`, where mid = (start + end)/2; else if array has even number of elements, return average of `A[mid]` + `A[mid+1]`. For example for array A = [1,5,9,12,15], median is 9. Complexity of this operation is O(1).

Focus back on two sorted arrays. To find median of two sorted arrays in no more simple and O(1) operation. For example, A = [ 1,5,9,12,15] and B = [ 3,5,7,10,17], median is 8. How about merging these two sorted array into one, problem is reduced to find median of one array. In above example, it will be C = [1,3,5,5,7,9,10,12,15,17]. Although to find median in a sorted array is `O(1)`, merge step takes O(N) operations. Hence, overall complexity would be `O(N)`. Reuse the merge part of Merge sort algorithm to merge two sorted arrays.
Start from beginning of two arrays and advance the pointer of array whose current element is smaller than current element of other. This smaller element is put on to output array which is sorted merge array. Merge will use an additional space to store N elements (Note that N is here sum of size of both sorted arrays). Best part of this method is that it does not consider if size of two arrays is same or different. It works for all size of arrays.

This can be optimized, by counting number of elements, N, in two arrays in advance. Then we need to merge only N/2+1 elements if N is even and N/2 if N is odd. This saves us O(N/2) space.

There is another optimization:do not store all N/2 or N/2+1 elements while merging, keep track of last two elements in sorted array, and count how many elements are sorted. When N/2+1 elements are sorted return average of last two elements if N is even, else return N/2 element as median. With this optimizations, time complexity remains O(N), however, space complexity reduces to O(1).

## Median of two sorted arrays implementation

```package com.company;

/**
* Created by sangar on 18.4.18.
*/
public class Median {

public static double findMedian(int[] A, int[] B){
int[] temp = new int[A.length + B.length];

int i = 0;
int j = 0;
int k = 0;
int lenA = A.length;
int lenB = B.length;

while(i<lenA && j<lenB){
if(A[i] <= B[j]){
temp[k++] = A[i++];
}else{
temp[k++] = B[j++];
}
}
while(i<lenA){
temp[k++] = A[i++];
}
while(j<lenB){
temp[k++] = B[j++];
}

int lenTemp = temp.length;

if((lenTemp)%2 == 0){
return ( temp[lenTemp/2-1] + temp[lenTemp/2] )/2.0;
}
return temp[lenTemp/2];
}

public static void main(String[] args){
int[] a = {1,3,5,6,7,8,9,11};
int[] b = {1,4,6,8,12,14,15,17};

double median = findMedian(a,b);
System.out.println("Median is " + median);
}
}
```

Complexity to find median of two sorted arrays using merge operation is O(N).
Optimized version to find median of two sorted arrays

```package com.company;

/**
* Created by sangar on 18.4.18.
*/
public class Median {

public  static int findMedianOptimized(int[] A, int[] B){
int i = 0;
int j = 0;
int k = 0;
int lenA = A.length;
int lenB = B.length;

int mid = (lenA + lenB)/2;
int midElement = -1;
int midMinusOneElement = -1;

while(i<lenA && j<lenB){
if(A[i] <= B[j]){
if(k == mid-1){
midMinusOneElement = A[i];
}
if(k == mid){
midElement = A[i];
break;
}
k++;
i++;
}else{
if(k == mid-1){
midMinusOneElement = B[j];
}
if(k == mid){
midElement = B[j];
break;
}
k++;
j++;
}
}
while(i<lenA){
if(k == mid-1){
midMinusOneElement = A[i];
}
if(k == mid){
midElement = A[i];
break;
}
k++;
i++;
}
while(j<lenB){
if(k == mid-1){
midMinusOneElement = B[j];
}
if(k == mid){
midElement = B[j];
break;
}
k++;
j++;
}

if((lenA+lenB)%2 == 0){
return (midElement + midMinusOneElement)/2;
}
return midElement;
}

public static void main(String[] args){
int[] a = {1,3,5,6,7,8,9,11};
int[] b = {1,4,6,8,12,14,15,17};

double median = findMedianOptimized(a,b);
System.out.println("Median is " + median);
}
}
```

## Median of two sorted array using binary search

One of the property which leads us to think about binary search is that two arrays are sorted. Before going deep into how Binary search algorithm can solve this problem, first find out mathematical condition which should hold true for a median of two sorted arrays.
As explained above, median divides input into two equal parts, so first condition median index m satisfy is `a[start..m]` and `a[m+1..end] ` are equal size. We have two arrays A and B, let’s split them into two. First array is of size m, and it can be split into m+1 ways at 0 to at m. If we split at i, length(A_left) – i and length(A_right) = m-i.

When i=0, len(A_left) =0 and when i=m, len(A_right) = 0.

Similarly for array B, we can split it into n+1 way, j being from 0 to n.

After split at specific indices i and j, how can we derive condition for median, which is left part of array should be equal to right part of array?

If len(A_left) + len(B_left) == len(A_right) + len(B_right) , it satisfies our condition. As we already know these values for split at i and j, equation becomes

```i+j = m-i + n-j
```

But is this the only condition to satisfy for median? As we know, median is middle of sorted list, we have to guarantee that all elements on left array should be less than elements in right array.
It is must that max of left part is less than min of right part. What is max of left part? It can be either `A[i-1]` or `B[j-1]`. What can be min of right part, it can be either `A[i]` or `B[j]`. We already know that, A[i-1] < A[i] and B[j-1]<B[j] as arrays A and B are sorted. All we need to check if A[i-1] <= B[j] and B[j-1]<=A[i], if index i and j satisfy this conditions, then median will be average of max of left part and min of right part if n+m is even and `max(A[i-1], B[j-1])` if n+m is odd.

Let’s make an assumption that n>=m, then j = (n+m+1)/2 -i, it will always lead to j as positive integer for possible values of i (o ~m) and avoid array out of bound errors and automatically makes the first condition true.

Now, problem reduces to find index i such that A[i-1] <= B[j] and B[j-1]<=A[i] is true.

This is where binary search comes into picture. We can start i as mid of array A, j = (n+m+1)/2-i and see if this i satisfies the condition. There can be three possible outcomes for condition.
1. `A[i-1]` <= `B[j]` and `B[j-1]`<=`A[i]` is true, we return the index i.
2. If `B[j-1]` > `A[i]`, in this case, A[i] is too small. How can we increase it? by moving towards right. If i is increased, value A[i] is bound to increase, and also it will decrease j. In this case, B[j-1] will decrease and A[i] will increase which will make B[j-1]<=A[i] is true. So, limit search space for i to mid+1 to m and go to step 1.
3. `A[i-1]` > `B[j]`, means A[i-1] is too big. And we must decrease i to get A[i-1]<=B[j]. Limit search space for i to 0 mid-1 and go to step 1

Let’s take an example and see how this works. Out initial two array as follows.

Index i is mid of array A and corresponding j will as shown

Since condition B[j-1] <= A[i] is not met, we discard left of A and right of B and find new i and j based on remaining array elements.

Finally our condition that A[i-1]<= B[j] and B[j-1] <=A[i] is satisfied, find max of left and min of right and based on even or odd length of two arrays, return average of max of left and min of right or return max of left.

This algorithm has very dangerous implementation caveat, which what if i or j is 0, in that case i-1 and j-1 will  be invalid indices. When can j be zero, when i == m. Till i<m, no need to worry about j being zero. So be sure to check i<m and i>0, when we are checking j-1 and i-1 respectively.

### Implementation

```package com.company;

/**
* Created by sangar on 18.4.18.
*/
public class Median {

public static double findMedianWithBinarySearch(int[] A, int[] B){

int[] temp;

int lenA = A.length;
int lenB = B.length;

/*We want array A to be always smaller than B
so that j is always greater than zero
*/
if(lenA > lenB){
temp = A;
A = B;
B = temp;
}

int iMin = 0;
int iMax = A.length;
int midLength =  ( A.length + B.length + 1 )/2;

int i = 0;
int j = 0;

while (iMin <= iMax) {
i = (iMin + iMax) / 2;
j = midLength - i;
if (i < A.length && B[j - 1] > A[i]) {
// i is too small, must increase it
iMin = i + 1;
} else if (i > 0 && A[i - 1] > B[j]) {
// i is too big, must decrease it
iMax = i - 1;
} else {
// i is perfect
int maxLeft = 0;
//If there we are at the first element on array A
if (i == 0) maxLeft = B[j - 1];
//If we are at te first element of array B
else if (j == 0) maxLeft = A[i - 1];
//We are in middle somewhere, we have to find max
else maxLeft = Integer.max(A[i - 1], B[j - 1]);

//If length of two arrays is odd, return max of left
if ((A.length + B.length) % 2 == 1)
return maxLeft;

int minRight = 0;
if (i == A.length) minRight = B[j];
else if (j == B.length) minRight = A[i];
else minRight = Integer.min(A[i], B[j]);

return (maxLeft + minRight) / 2.0;
}
}
return -1;
}

public static void main(String[] args){
int[] a = {1,3,5,6,7,8,9,11};
int[] b = {1,4,6,8,12,14,15,17};

double median = findMedian(a,b);
System.out.println("Median is " + median);
}
}
```

Complexity of this algorithm to find median of two sorted arrays is log(max(m,n)) where m and n are size of two arrays.

In last post, we discussed inversions in array. One more problem on similar lines, given an array of integers, find all leaders in array. First of all, let’s understand what is a leader. Leader is an element in array which is greater than all element on right side of it. For example:
In array below element 8, 5 and 4 are leaders. Note that element at index 6 is leader by not at index 1.

Another example, in this there are only two leaders which is 10 and 9.

Clarifying question which becomes evident in example is that if last element is considered as leader? Based on answer from interviewer, function should print or not last element.

## Leaders in array : thought process

What is brute force approach? Scan through all elements in array one by one and check if there is any greater element on right side. If there is no such element, number is leader in array.

```package com.company;

import java.util.ArrayList;
import java.util.Stack;

/**
* Created by sangar on 7.4.18.
*/

for(int i=0; i<a.length; i++){
int j = 0;
for(j=i+1; j<a.length; j++){
if(a[i] < a[j]){
break;
}
}
}

}

public static void main(String[] args) {
int a[] = new int[]{90, 20, 30, 40, 50};
}
}
```

Complexity of brute force solution to find leaders in array is O(n2).

Let’s go to basics of question: All elements on right side of an element should be less than it for that element to be leader. Starting from index 0, we can assume that A[0] is leader and move forward. Remove `A[0]` if `A[1] > A[0]` as A[0] is not leader anymore. Now, if `A[2] > A[1]`, then A[1] cannot be leader.
What if `A[3] < A[2]`, then A[2] may still be leader and A[3] may also be.
What if `A[4] > A[3]`, then A[3] cannot be leader. Can A[2] be leader? Depends if A[4] is less or more than A[2]. For each element, we are going back to all previous candidate leaders in reverse way and drop all candidates which are less than current element. Does it ring bell?Well, data structure which supports this kind of operation Last In First Out, is stack.
Stack supports two operations : push and pop. Question is when to push and pop and elements from stack for our problem.

Push element if it less than top of stack. If top of stack is less than current element, pop elements from stack till an element which is greater than current element. When entire array is scanned, stack will contain all leaders.

• Start with empty stack. Push first element of array on to it.
• For each element in array
• Till current element is greater than top, pop element.
• Push current element on to stack.
•  At the end of processing, stack will contain all leaders.

## Leaders in array : Implementation using stack

```package com.company;

import java.util.ArrayList;
import java.util.Stack;

/**
* Created by sangar on 7.4.18.
*/

Stack<Integer> s = new Stack();
s.push(a[0]);

for(int i=1; i<a.length; i++){
while(s.peek() < a[i]){
s.pop();
}
s.push(a[i]);
}

while (!s.empty()){
}
}
public static void main(String[] args) {
int a[] = new int[]{90, 20, 30, 40, 50};
}
}
```

Complexity of algorithm using stack to find leaders in array is O(n) with extra O(n) space complexity.

Scanning array in reverse
How can we avoid the additional space used by stack? When we are scanning forward, there are chances that some element going forward will be current candidate leader. That is why we keep track of all candidate leaders. How about scanning array from end, in reverse order. Start with last index and keep track of maximum we saw till current index. Check if element at current index is greater than current max, save it as leader and change current max to current element.

##### Algorithm to find leaders without extra space
• Set current max as last element of array.
• For i = n-1 to 0 index of array
• if a[i] greater than current max
• Change current max to a[i]

### Leaders in array implementation without extra space

```package com.company;

import java.util.ArrayList;
import java.util.Stack;

/**
* Created by sangar on 7.4.18.
*/

int currentMax = Integer.MIN_VALUE;
for(int i=a.length-1; i>=0; i--){
if(a[i] > currentMax ){
currentMax = a[i];
}
}

}
public static void main(String[] args) {
int a[] = new int[]{90, 20, 30, 40, 50};
}
}

```

Complexity of reverse array algorithm to find leaders in array is O(n) with no added space complexity.

Please share you views,suggestion, queries or if you find something wrong. If you want t contribute to algorithms and me, please reach out to us on communications@algorithmsandme.com

# Pair with given sum in array

Given an array a[] and a number X, find two elements or pair with given sum X in array. For example:

```Given array : [3,4,5,1,2,6,8] X = 10
Answer could be (4,6) or (2,8).```

Before looking at the post below, we strongly recommend to have pen and paper and git it a try to solve it.

## Pair in array with given sum : thought process

Ask some basic questions about the problem, it’s a good way to dig more into problem and gain more confidence. Remember interviewers are not trained interrogators, they slip hint or two around solution when you ask relevant questions.

• Is it a sorted array ? If not, think additional complexity you would be adding to sort it
• If duplicates present in array?
• Whether returning first pair is enough or should we return all such pairs with sum equal to X?
• If there can be negative numbers in array?

This problem is used regularly in interviews because it tests so many things about your programming knowledge.
It validates that if you can traverse array properly, with both lower and higher bounds. It also checks your optimizing ability once you got a working solution. Can you work with additional constraints? Are you able to work with more than one data structure like array and hash together to solve a problem?

## Find pairs with given sum : Using sorting

Let’s go with an assumption that input is sorted array and if not, we will sort it? If you want to know how to sort an array efficiently,refer Quick sort or Merge sort
With sorted array, we can apply below algorithm to find a pair with given sum.

1. Initialize two variable `left` = 0 and `right` = array.length-1, These variable are used to traverse array from two ends of array.
2. While two variables left and right do not cross each other,
3. Get sum of elements at index left and right, i.e `A[left] + A[right]`
4. If sum is greater than X, move towards left from end i.e decrease right by 1
5. Else if sum is less than X,then move towards right from start, i.e increment left
6. At last, if sum is equal to X, then return `(left, right)` as pair.

##### Example

Let’s see how this works with an example and then we will implement it. Given an array as shown and sum = 17, find all pair which sum as 17.

Initialization step, left = 0 and right = array.length – 1

A[left] + A[right] = 20 which is greater than sum (17), move right towards left by 1.

Again, A[left] + A[right] = 18 which is greater than sum (17), move right towards left by 1.

At this point, A[left] + A[right] is less than sum(17), hence move left by 1

Now, A[left] + A[right]  is equal to sum and so add this pair in result array. Also, decrease right by 1, why?

At this point, A[left] + A[right] is less than sum(17), hence move left by 1

Again, A[left] + A[right] is less than sum(17), hence move left by 1

A[left] + A[right]  is equal to sum and so add this pair in result array. Also, decrease right by 1.

Since, left and right point to same element now, there cannot be a pair anymore, hence return.

```package com.company;

import javafx.util.Pair;

import java.util.ArrayList;

/**
* Created by sangar on 5.4.18.
*/
public class PairWithGivenSum {
public static ArrayList<Pair<Integer, Integer>> pairWithGivenSum(int[] a, int sum){
int left = 0;
int right = a.length - 1;

ArrayList<Pair<Integer, Integer>> resultList = new ArrayList<>();

while(left < right){
/*If sum of two elements is greater than
sum required, move towards left */
if(a[left] + a[right] > sum) right--;
/*
If sum of two elements is less than
sum required, move towards right
*/
if(a[left] + a[right] < sum) left++;
if(a[left] + a[right] == sum){
right--;
}
}
return resultList;
}
public static void main(String[] args) {
int a[] = new int[] {10, 20, 30, 40, 50};

ArrayList<Pair<Integer, Integer>> result = pairWithGivenSum(a,50);
for (Pair<Integer, Integer> pair : result ) {
System.out.println("("+ pair.getKey() + "," + pair.getValue()  + ")");
}
}
}
```

Complexity of this algorithm to find a pair of numbers in array with sum X is dependent on sorting algorithm used. If it is merge sort, complexity is `O(n log n)` with added space complexity of `O(n)`. If quick sort is used, worst case complexity is `O(n2)` and no added space complexity.

## Find a pair with given sum in array : Without sorting

In first method,  array is modified, when it is not already sorted. Also, Preprocessing step (sorting) dominates the complexity of algorithm. Can we do better than `O(nlogn)` or in other words, can we avoid sorting?

Additional constraint put on problem is that  you cannot modify original input.  Use basic mathematics, if A + B = C, then A = C-B.  Consider B is each element for which we are looking for A. Idea is to scan entire array and find all A’s required for each element. Scan array again and check there was B which required current element as A.
To keep track of required A values, we will create an hash, this will make second step O(1).
We can optimize further by scanning array only once for both steps.

1. Create an hash
2. Check element at each index of array
2.a If element at current index  is already in hash. return pair of current index and value in hash
2.b If not, then subtract element from sum and store (sum-A[index], index) key value pair in hash.

This algorithm scans array only once and does not change input. Worst case time complexity is O(n), hash brings additional space complexity. How big should be the hash? Since, all values between sum-max value of array and sum-min value of array will be candidate A’s hence hash will be of difference between these two values.

This solution does not work in C if there are negative numbers in array. It will work in languages which have HashMaps in-built. For C, we have to do some preprocessing like adding absolute of smallest negative number to all elements. That’s where our fourth question above helps us to decide.

### Pairs with given sum : implementation

```package com.company;

import javafx.util.Pair;

import java.util.ArrayList;
import java.util.HashMap;

/**
* Created by sangar on 5.4.18.
*/
public class PairWithGivenSum {
public static ArrayList<Pair<Integer, Integer>> pairsWithGivenSum2(int[] a, int sum){
int index = 0;
ArrayList<Pair<Integer, Integer>> resultList = new ArrayList<>();

HashMap<Integer, Integer> pairMap = new HashMap<>();
for(int i=0; i< a.length; i++){
if(pairMap.containsKey(a[i])){
}
pairMap.put(sum-a[i], i);
}
return resultList;
}
public static void main(String[] args) {
int a[] = new int[] {10, 20, 30, 40, 50};

ArrayList<Pair<Integer, Integer>> result = pairsWithGivenSum2(a,50);
for (Pair<Integer, Integer> pair : result ) {
System.out.println("("+ pair.getKey() + "," + pair.getValue()  + ")");
}
}
}

```

Please share if there is some error or suggestion to improve. We would love to hear what you have to say. If you want to contribute to learning process of other by sharing your knowledge, please write to us at communications@algorithmsandme.com

# Find Minimum  in sorted rotated array

In post find element in sorted rotated array, we discussed an algorithm based on binary search, to find a given key in sorted rotated array.  Problem today is bit different, there is no key to find first of all. Ask of problem is to find minimum in sorted rotated array.

To understand problem, first let’s understand what is sorted array and then what is sorted rotated array.

An array is called sorted where for all i and j such that i < j, A[i] <= A[j]. A rotation happens when last element of array is push at the start and all elements of array move right by one position. This is called as rotation by 1. If new last element is also pushed to start again, all elements are moved to right, it’s rotation by 2 and so on.

Find minimum in sorted rotated array problem is asked during telephonic or online coding rounds of companies like Microsoft or Amazon.

## Find minimum in sorted rotated array : Thought process

As always, first come up with a brute force solution without worrying about any optimizations as of now. Simplest way would be to scan through array and keep track of minimum. Complexity of this method is O(N), however, what is the fun if we do it in O(N) time complexity ?

In brute force solution, we did not use the fact that array is sorted and then rotated. Let’s forget about rotation and concentrate only in sorted part.

What is minimum element in sorted array? Obviously, it is the first element of array. We see that all the elements on right side of minimum elements are greater than minimum.

What will happen if start rotating array now, is the condition that all the elements on right of minimum element are greater than it still hold? Yes, it does. Either there will be no element on right side of minimum or the will be definitely greater than it.

So, idea is we randomly pick an element and see if elements on right side of it are greater. No need to go through each element, compare selected element with last index element, if last index element is greater, selected element can be minimum. (Remember we are working sorted array!).
Start comparing with middle element. What information comparison between middle and end element gives us?
Array could have been in two ways : It is rotated more than half or it is rotated less than half.
If middle element is less than last element, array is rotated less than half, and hence, minimum element should be on the left half of array.
If middle element will be greater than last element, array is rotated more than half, hence minimum element should be in right part of array.
What if middle element is the minimum element? See if element on left and right of mid are both greater than element at mid, mid is index of minimum element.
Let’s take an example and see how this method works and then come up with concrete algorithm to find minimum in sorted rotated array. For example, array is given as below.
First, we find the mid, check if mid is minimum?  A[mid] > A[mid-1], so it cannot be minimum element. So, see if array is rotated more than half or less than half.
Since, A[mid] > A[end], array is rotated more than half and hence, minimum should be on the right side.
We will discard the left subarray and focus on right subarray to find minimum.
Again, find the mid, is mid the minimum? No, so compare it with end, since, A[mid] < A[end],  minimum should be on the left side, discard right subarray.
Find mid again and this time mid satisfy the condition : A[mid-1] and A[mid+1] both are greater than A[mid], hence, A[mid] should be the minimum element.
Can you come up with execution trace when array is not rotated more than half to start with?

## Minimum in sorted rotated array : Algorithm

1. Find mid = start + (end- start) /2
2. See if mid is minimum element i.e is A[mid] < A[mid-1] and A[mid] < A[mid+1]. If yes, return mid
3. Else if A[mid] > A[end]:
• Array is rotated more than half, minimum should be on right subarray
• Continue with subarray with start =  mid+1
4. Else if A[mid] < A[end]:
• Array is rotated less than half, minimum should be on left subarray
• Continue with subarray with end = mid-1

### Minimum in sorted rotated array implementation

```package com.company;

/**
* Created by sangar on 22.3.18.
*/
public class SortedRotatedArray {

public static int findMinimumIterative(int[] input, int start, int end) {

while (start < end) {
int mid = start + (end - start) / 2;

if (mid == 0 || (input[mid] <= input[mid+1]
&& input[mid] < input[mid-1])) return mid;
else if (input[mid] > input[mid]) {
/* Array is rotated more than half, hence minimum
should be in right sub-array
*/
start  = mid + 1;
} else {
/* Array is rotated less than half, hence minimum
should be in left sub-array
*/
end  = mid - 1;
}
}
return start;
}
public static void main(String[] args) {
int[] input = {10,11,15,17,3,3,3,3,3,3};

int index = findMinimumIterative(input,0, input.length-1);
System.out.print(index == -1 ? "Element not found" : "Element found at : " + index);

}
}
```

Recursive implementation of same function

```package com.company;

/**
* Created by sangar on 22.3.18.
*/
public class SortedRotatedArray {

public static int findMinimumRecursive(int[] input, int start, int end){

if(start < end){
int mid = start + (end - start) / 2;

if(mid == 0 || (input[mid] < input[mid-1]
&& input[mid] <= input[mid+1] ) ) return mid;

else if(input[mid] > input[end]){
/* Array is rotated more than half and hence,
search in right subarray */
return findMinimumRecursive(input, mid+1, end);
}else {
return findMinimumRecursive(input, start, mid - 1);
}
}
return start;
}

public static void main(String[] args) {
int[] input = {3,10,11,15,17,18,19,20};

int index = findMinimumRecursive(input,0, input.length-1);
System.out.print(index == -1 ? "Element not found" : "Element found at : " + index);

}
}
```

Complexity of algorithm to find minimum in sorted rotated array is O(log N), with recursive implementation having implicit space complexity of O(log N).

What did we learn from this problem?
First learning is to always go for brute force method. Second, try to draw the effect of any additional operations which are done on original array. In sorted rotated array, try to have rotation one by one and see what impact it has on minimum element? Try to classify individual class and design your algorithm. In this problem, we identify that based on how many times array is rotated, minimum can be in right or left subarray from middle and that gave idea for discarding half of the array.

Please share if there is something wrong or missing, or any improvement we can do. Please reach out to us if you are willing to share your knowledge and contribute to learning process of others.

# Find element in sorted rotated array

To understand how to find element in sorted rotated array, we must understand first, what is a sorted rotated array? An array is called sorted where for all i and j such that i < j, A[i] <= A[j]. A rotation happens when last element of array is push at the start and all elements on array move right by one position. This is called as rotation by 1. If new last element is also pushed to start again all elements are moved to right again, it’s rotation by 2 and so on.

Question which is very commonly asked in Amazon and Microsoft initial hacker round interviews or telephonic interviews : Given a sorted rotated array, find position of an element in that array. For example:

A = [2,3,4,1] Key = 4, Returns 2 which is position of 4 in array

A = [4,5,6,1,2,3] Key = 4 returns 0

## Find element in sorted rotated array : Thought process

Before starting with any solution, it’s good to ask some standard questions about an array problem, for example, if duplicate elements are allowed or if negative numbers are allowed in array? It may or may not change the solution, however, it gives an impression that you are concerned about input range and type.

First thing to do in interview is come up with brute force solution, why? There are two reasons : first, it gives you confidence that you have something solved, it may not be optimal way but still you have something. Second, now that you have something written, you can start looking where it takes most of time or space and attack the problem there. It also, helps to identify what properties you are not using which are part of the problem and help your solution.

First thing first, what will be the brute force solution? Simple solution will be to scan through the array and find the key. This algorithm will have `O(N)` time complexity.

There is no fun in finding an element in sorted array in O(N) 🙂 It would have been the same even if array was not sorted. However, we already know that our array is sorted. It’s also rotated, but let’s forget about that for now. What do we do when we have to find an element in sorted array? Correct, we use binary search.

We split the array in middle and check if element at middle index is the key we are looking for? If yes, bingo! we are done.

If not, if A[mid] is less that or greater than key. If it is less, search in right subarray, and it is greater, search in left subarray. Any which way, our input array is reduced to half. Complexity of binary search algorithm is `log (N)`. We are getting somewhere 🙂

### Sorted rotated array

However, our input array in not a plain sorted array, it is rotated too. How does things change with that. First, comparing just middle index and discarding one half of array will not work. Still let’s split the array at middle and see what extra conditions come up?
If `A[mid]` is equal to key, return middle index.
There are two broad possibilities of rotation of array, either it is rotated more than half of elements or less than half of elements. Can you come up with examples and see how array looks like in both the cases?

If array is rotated by more than half of elements of array, elements from start to mid index will be a sorted.

If array is rotated by less than half of elements of array, elements from mid to end will be sorted.

Next question, how do you identify the case, where array is rotated by more or less than half of elements? Look at examples you come up with and see if there is some condition?

Yes, the condition is that if `A[start] ` < `A[mid]`, array is rotated more than half and if A[start] > `A[mid]`, it is rotated by less than half elements.

Now, that we know, which part of array is sorted and which is not. Can we use that to our advantage?

Case 1 : When array from start to mid is sorted. We will check if `key > A[start]` and `key < A[mid]`. If that’s the case, search for key in `A[start..mid]`. Since, `A[start..mid]` is sorted, problem reduces to plain binary search. What if key is outside of start and middle bounds, then discard A[start..mid] and look for element in right subarray. Since, `A[mid+1..right]` is still a sorted rotated array, we follow the same process as we did for the original array.

Case 2 : When array from mid to end is sorted. We will check if `key >A[mid]` and `key < A[end]`. If that’s the case, search for key in A[mid+1..end]. Since, `A[mid+1..end]` is sorted, problem reduces to plain binary search. What if key is outside of mid and end bounds, then discard `A[mid..end]` and search for element in left subarray. Since, `A[start..mid-1]` is still a sorted rotated array, we follow the same process as we did for the original array.

Let’s take an example and go through the entire flow and then write concrete algorithm to find element in sorted rotated array.

Below is sorted rotated array given and key to be searched is 6.

We know, A[start] > A[mid], hence check if searched key fall under range A[mid+1..end]. In this case, it does. Hence, we discard A[start..mid].

At this point, we have to options:  either fallback to traditional binary search algorithm or continue with same approach of discarding based on whether key falls in range of sorted array. Both methods work. Let’s continue with same method.

Again find middle of array from middle +1 to end.

A[mid] is still not equal to key. However, A[start] < A[mid]; hence, array from A[start] to A[middle] is sorted. See if our key falls between A[start] and A[mid]? Yes, hence, we discard the right sub array A[mid..End]

Find the middle of remaining array, which is from start to old middle – 1.

Is A[mid] equal to key? No. Since, A[start] is not less than A[mid], see if key falls under A[mid+1..end], it does, hence discard the left subarray.

Now, new middle is equal to key are searching for. Hence return the index.

Similarly, we can find 11 in this array. Can you draw the execution flow that search?

## Algorithm to find element in sorted rotated array

1. Find mid =  (start + end)/ 2
2. If A[mid] == key; return mid
3. Else, if A[start] < A[end]
• We know, left subarray is already sorted.
• If A[start] < key and A[mid] > key :
• Continue with new subarray with start and end = mid – 1
• Else:
• Continue with new subarray with start = mid + 1 and end
4. Else
• We know, right subarray is sorted.
• If A[mid] < key and A[end] > key :
• Continue with new subarray with start  = mid + 1 and end
• Else:
• Continue with new subarray with start and end = mid – 1

### Find element in sorted rotated array : Implementation

```package com.company;

/**
* Created by sangar on 22.3.18.
*/
public class SortedRotatedArray {

public static int findElementRecursive(int[] input, int start, int end, int key){

if(start <= end){
int mid = start + (end - start) / 2;

if(input[mid] == key) return mid;

else if(input[start] <= input[mid]){
/*Left sub array is sorted, check if
key is with A[start] and A[mid] */
if(input[start] <= key && input[mid] > key){
/*
Key lies with left sorted part of array
*/
return findElementRecursive(input, start, mid - 1, key);
}else{
/*
Key lies in right subarray
*/
return findElementRecursive(input, mid + 1, end, key);
}
}else {
/*
In this case, right subarray is already sorted and
check if key falls in range A[mid+1] and A[end]
*/
if(input[mid+1] <= key && input[end] > key){
/*
Key lies with right sorted part of array
*/
return findElementRecursive(input, mid + 1 , end, key);
}else{
/*
Key lies in left subarray
*/
return findElementRecursive(input, start, mid - 1, key);
}
}
}
return -1;
}

public static void main(String[] args) {
int[] input = {10,11,15,17,3,5,6,7,8,9};

int index = findElementRecursive(input,0, input.length-1, 6);
System.out.print(index == -1 ?

}
}
```

Iterative implementation

```package com.company;

/**
* Created by sangar on 22.3.18.
*/
public class SortedRotatedArray {

public static int findElementIteratve(int[] input, int start, int end, int key) {

while (start <= end) {
int mid = start + (end - start) / 2;

if (input[mid] == key) return mid;

else if (input[start] <= input[mid]) {
/*Left sub array is sorted, check if
key is with A[start] and A[mid] */
if (input[start] <= key && input[mid] > key) {
/*
Key lies with left sorted part of array
*/
end = mid - 1;
} else {
/*
Key lies in right subarray
*/
start  = mid + 1;
}
} else {
/*
In this case, right subarray is already sorted and
check if key falls in range A[mid+1] and A[end]
*/
if (input[mid + 1] <= key && input[end] > key) {
/*
Key lies with right sorted part of array
*/
start = mid + 1;
} else {
/*
Key lies in left subarray
*/
end  = mid - 1;
}
}
}
return -1;
}

public static void main(String[] args) {
int[] input = {10,11,15,17,3,5,6,7,8,9};

int index = findElementIteratve(input,0, input.length-1, 6);
System.out.print(index == -1 ? "Element not found" : "Element found at : " + index);

}
}
```

Complexity of above recursive and iterative algorithm to find an element in a rotated sorted array is `O(log n)`. Recursive implementation has implicit space complexity of `O(log n)`

What did we learn today? We learned that it’s always better to come up with non-optimized solution first and then try to improve it. Also helps to correlate problem with similar and simpler problem like we understood first what is best way to find an element in sorted array and then extrapolated the solution with additional conditions for our problem.

I hope that this post helped you with this problem and many more similar problems you will see in interviews.

# Consistent Hashing

To understand consistent hashing, first of all we have to understand traditional hashing and it’s limitations in large scale distributed system.

Hashing in plain terms is nothing but a key value pair store, where given a key, associated value can be found very efficiently. Example : Let’s say we want to find a name of a street in city given it’s zip code. Idea is to store this information as hash as <Zip code, Street Name>.

Problem becomes more interesting when data is too big to store on one node or machine, multiple such nodes or machines are required in system to store it. For example, a system which uses number of web caches. First question: How to decide which key goes on which node? Simplest solution is use modulo function to decide. Given a key, take hash of key,  divide it by number of nodes in system and then put that key on to that node. Similarly, when fetching key, hash the key, divide with number of nodes and then go to that node and fetch value. Picture depicts conventional hashing in multi-node system.

Failures are common in commodity hardware driven distributed multi-node system. Any node can die without any prior notice and expectation is that system runs unaffected with slight cost on performance. What happens when in system described above, a node goes down?  In traditional hashing, total number of nodes have decreased, so function determining node to put key on or fetch key from, changes. New keys will be working fine. What happens to existing keys? They are all in wrong nodes as per new function.

To fix this problem, we have to redistribute all existing keys on remaining nodes, which may be very costly operation and can have detrimental effects on running system. Again what happens when node comes back? well, repeat what was done when node went down. This may result in thrashing effect where if a node misbehaves regularly, system would do no good work except from re-distribution of keys.

How to solve this challenge? This is where consistent hashing comes into picture.

## Consistent hashing in distributed multi-node systems

Consistent hashing comes up with a very simple idea, that is to have nodes and keys in same id space unlike traditional hashing where node id and keys were in two different id space. Node id can be hash function to IP address and then same hash function is applied to keys to determine which node key goes on or to fetch from.

Critical requirement for consistent hashing implementation is to have a hash function which is consistent irrespective of system view and map keys roughly uniformly on all machines.

Chose any base hash function such that it maps a key space to integers in range [0..M]. Once we divide it with M, it gives us an unit circle. Now, each key once hashed represents a point on this unit circle.

How does key maps to a node exactly? Well, key is hashed and then put key on to first node you find while moving clockwise. Simple enough, huh? To find a key, take hash and go to first node while moving clockwise on to unit circle.

How does it solve the problem of scale? Let’s my system is receiving  5 x load, what happens to nodes and how can I balance load or reduce it? Simple thing is to add more nodes uniformly distributed on unit circle and problem solved. Consistent hashing built of scale.

What happens when a node goes down? All the keys which were on this node are reallocated to next successor node on circle. All other keys remain unchanged. This is far more optimal compared to case when we have re-distribute all keys on failure of one node.

As mentioned earlier, we assume that hash function used will distribute keys on nodes uniformly, which is not realistic. To reduce non-uniformity,  virtual nodes are introduced. In this case, each nodes is hashed with K different hash function which maps nodes on different points on circle. Still node is going to get 1/N keys however, virtual nodes reduces key load variance significantly.

One challenge still remains : How to efficiently find successor node for a given key, we want to find source s such that h(s) > h(k) of key k. Intuitive solution is to use hash, but hashes do not maintain any ordering information. Best bet is to use binary search tree which maintain ordering, but the successor function is proportional to depth of tree which is O(N), We can reduce that by using balance binary search trees like red black trees which reduces complexity to log(N).

### Where all consistent hashing is used?

Consistent hashing is used in Memcached, Casandra Amazon Dynamo etc.

If you find this article useful, please share. If there is something missing or wrong in article please share and we will correct it.

Reference:

http://theory.stanford.edu/~tim/s16/l/l1.pdf

http://www8.org/w8-papers/2a-webserver/caching/paper2.html

# Find Kth smallest element in two sorted arrays

We have already solved problem to find kth smallest element in an array using quick sort modification and min heap. Today, our problem is to find Kth smallest element in two sorted arrays. In another words, given two sorted arrays, find Kth smallest element of union of these two arrays.

For example if A = [10, 20, 40, 60] and B =[15, 35, 50, 70, 100] and K = 4 then solution should be 35 because union of above arrays will be C = [10,15,20,35,40,50,60,70,100] and fourth smallest element is 35.

## Kth smallest element in two sorted arrays

As I always insist on doing : what will be the most brute force solution for this problem. Simple, merge two sorted arrays into one and return Kth smallest element merged array. There are different ways to merge two sorted arrays , merge part of merge sort will be most efficient when two parts are already sorted. Time complexity of merge is O(n+m) and additional space complexity of O(m+n) where m and n are sizes of two sorted arrays.

Now that we already know brute force solution, can we do better than this?
kth smallest element can be present in any one of the two arrays. How many elements can we include from first array A, with size m, it can be max(k-1, m).
Let’s suppose we took i elements from first array, how many maximum number of elements we can take from array B? Since, we have zero based indexing of array,

```i+j = k-1
```

Now, we need to find combination of `i` and `j` such that all elements from 0 to i are less than B[j] and all elements from 0 to j should be smaller than A[i], and min(A[i], B[j]) will be the kth smallest element.

For A[i], all elements from index 0 to i-1 are smaller, all we need to check is that all elements in array B from index 0 to index j-1 are smaller too. There for A[i] >= B[j-1]

Similarly for B[j], it must satisfy the condition B[j] >= A[i-1].

In order to be kth smallest element, index i and j have to satisfy two conditions, (A[i] >= B[j-1] && B[j] >= A[i-1]) and also i+j  =  k-1 or j = k-1-i

What if A[i] < B[j-1]  as we saw in first picture?  That means i is too small, we need to increase i and when we increase i and A[i], j and B[j] is decreased automatically, which makes it possible to satisfy A[i] >= B[j-1].

In the same vain when B[j] < A[i-1],  i is too big and it’s a good choice to decrease it.

This is where binary search comes into picture. We can start i as mid of array A, j = k-i and see if this i satisfies the condition. There can be three possible outcomes for condition.
1. `A[i-1]` >= `B[j]` and `B[j-1]` <=`A[i]` is true, we return the index min(A[i], B[j])
2. If`B[j-1]` > `A[i]`, in this case, A[i] is too small. How can we increase it? by moving towards right. If i is increased, value A[i] is bound to increase, and also it will decrease j. In this case, B[j-1] will decrease and A[i] will increase which will make B[j-1] >=A[i] is true. So, limit search space for i to  mid+1 to min(k, m)
3. `A[i-1]` > `B[j]`, means A[i-1] is too big. And we must decrease i to get A[i-1] >=B[j]. Limit search space for i from 0 to i-1.

Since, i is bound by 0 to min(k-1,m), j will never go below 0. When i or j is o, return min(A[i], B[j]).

There is lot to process I know, let’s take an example and see how it works. Below are the two sorted arrays and K  = 7.

First thing to notice is that k is greater than m, size of array A. Hence range of i will be 0 to m i.e. 5. Find mid, i = 2 and j = k – 2-1 = 4

Now, A[i] < B[j-1], it is evident that we chose i too small. Search space is now from i+1 to m.

Again we find mid which is index 4 of array A. Index j = 2. At this point condition A[i-1] <= B[j] is false. This means, we chose i too big and hence we decrease range till i-1 which now 3.

New i and j are shown below. Condition A[i-1] <= B[j] and B[j-1] <= A[j] is true. Return min(A[i], B[j]) as kth smallest element which is 6.

## Code to find Kth smallest element in two sorted arrays

```package com.company;

/**
* Created by sangar on 19.4.18.
*/
public class KthSmallestElement {

public static double findKthSmallestElement(int[] A, int[] B, int k){

int[] temp;

int lenA = A.length;
int lenB = B.length;

if(lenA + lenB < k) return -1;

int iMin = 0;
int iMax = Integer.min(A.length, k-1);

int i = 0;
int j = 0;

while (iMin <= iMax) {
i = (iMin + iMax) / 2;
j = k - 1 - i; // because of zero based index
if (B[j - 1] > A[i]) {
// i is too small, must increase it
iMin = i + 1;
} else if (i > 0 && A[i - 1] > B[j]) {
// i is too big, must decrease it
iMax = i - 1;
} else {
// i is perfect
return Integer.min(A[i], B[j]);
}
}
return -1;
}

public static void main(String[] args){
int[] a = {1,3,5,6,7,8,9,11};
int[] b = {1,4,6,8,12,14,15,17};

double smallest = findKthSmallestElement(a,b, 9);
System.out.println("Kth smallest element is : " + smallest);
}
}

```

Complexity of algorithm to find Kth smallest element in union of two arrays is O(log(N+M)).

Please share if there is something wrong or missing. we would be glad to hear from you.