Find median

O(n) look for the median(or any target rank) in an array

 

class Solution {
  public static void main(String[] args) {
    Solution solution = new Solution();
    solution.findMedian(new int[]{4, 1, 9});
    solution.findMedian(new int[]{4, 1, 9, 3});
    solution.findMedian(new int[]{4, 1, 9, 3, 0, 6, 1, 6, 4});
    solution.findMedian(new int[]{-1, 4, 1, 9, 3, 0, 6, 1, 6, 4});
    solution.findMedian(new int[]{4, 1, 9, 3, 0, 6, 1, 6, 4, 2, 3});
    solution.findMedian(new int[]{4, -10, -22, 1, 9, 3, 0, 6, 1, 6, 4, 2, 3});
    solution.findMedian(new int[]{4, 1, 9, 3, 0, 6, 12, 13, 1, 6, 4, 10, 2, 3});
  }

  void findMedian(int[] arr) {
    if (arr.length % 2 == 1) {
      int found = findSingleTarget(arr, 0, arr.length - 1, arr.length / 2);
      System.out.println(String.format("Rank (%d) found using findSingleTarget algorithm: %d", arr.length / 2, found));
    } else {
      int found1 = findSingleTarget(arr, 0, arr.length - 1, (arr.length - 1) / 2);
      // We don't need to look for twice, should be optimizable.
      int found2 = findSingleTarget(arr, 0, arr.length - 1, arr.length / 2);
      System.out
          .println(String.format("Rank (%d, %d) found using findSingleTarget algorithm: %s", (arr.length - 1) / 2,
              arr.length / 2, (found1 + found2) / 2.0));
    }

    Arrays.sort(arr);
    System.out.println(String
        .format("Sorted array: %s Total count: %d, number in the middle(%d): %d", Arrays.toString(arr), arr.length,
            arr.length / 2, arr[arr.length / 2]));
    System.out.println();
  }

  /**
   * @param target is the rank(index) of a value, which we are looking for, if this arr is sorted
   */
  int findSingleTarget(int[] arr, int leftInclusive, int rightInclusive, int target) {
    if (leftInclusive > rightInclusive) {
      throw new IllegalArgumentException();
    }
    if (leftInclusive == rightInclusive) {
      if (leftInclusive == target) {
        return arr[leftInclusive];
      }
      throw new IllegalArgumentException();
    }

    int left = leftInclusive;
    int right = rightInclusive;

    int pivot = arr[left]; //use the first element as the pivot
    ++left;

    while (left <= right) {
      int current = arr[left];
      if (current <= pivot) {
        //lazy "swap" pivot with left
        arr[left - 1] = arr[left];
        ++left;
      } else {
        //swap left and right
        swap(arr, left, right);
        --right;
      }
    }
    int pivotIndex = left - 1;
    arr[left - 1] = pivot;
    if (pivotIndex == target) {
      return pivot;
    }

    if (pivotIndex < target) {
      return findSingleTarget(arr, pivotIndex + 1, rightInclusive, target);
    }

    return findSingleTarget(arr, leftInclusive, pivotIndex - 1, target);
  }

  private void swap(int[] array, int a, int b) {
    int tmp = array[a];
    array[a] = array[b];
    array[b] = tmp;
  }
}

 

 

A similar idea can be used to partition an array into two subarrays where values from one array are strictly less than values from another array.

class Solution {
  public static void main(String[] args) {
    Solution solution = new Solution();
    System.out.println(solution.canPartition(new int[]{11, 6, 5, 1, 2, 4, 3}));
    System.out.println(solution.canPartition(new int[]{1, 1, 1, 1, 1, 3}));
    System.out.println(solution.canPartition(new int[]{4, 1, 2, 3}));
    System.out.println(solution.canPartition(new int[]{1, 2, 3, 4}));
    System.out.println(solution.canPartition(new int[]{1, 5, 7, 1}));
    System.out.println(solution.canPartition(new int[]{12, 7, 6, 7, 6}));
    System.out.println(solution.canPartition(new int[]{5, 1, 2, 3, 5}));
  }

  boolean canPartition(int[] arr) {
    int sum = 0;
    for (int num : arr) {
      sum += num;
    }

    if (sum % 2 != 0) {
      return false;
    }

    //return canPartitionInPlace(arr, 0, arr.length - 1, 0, sum / 2);
    return canPartition(arr, 0, sum / 2);
  }

  /**
   * An in-place solution for partition the array.
   */
  boolean canPartitionInPlace(int[] arr, int leftInclusive, int rightInclusive, int runningSum, int target) {
    if (leftInclusive > rightInclusive) {
      return false;
    }
    if (leftInclusive == rightInclusive) {
      return runningSum + arr[leftInclusive] == target;
    }

    int newSum = runningSum;
    int pivot = arr[rightInclusive];
    int boundary = leftInclusive;  //all values to the left of boundary are <= pivot

    for (int i = leftInclusive; i < rightInclusive; ++i) {
      if (arr[i] <= pivot) {
        newSum += arr[i];
        swap(arr, boundary++, i);
      }
    }

    //include the pivot to the left section
    swap(arr, boundary, rightInclusive);
    newSum += arr[boundary];

    if (newSum < target) {
      // boundary + 1 will point to a different value
      return canPartitionInPlace(arr, boundary + 1, rightInclusive, newSum, target);
    }

    if (newSum > target) {
      //the pivot should fall into right section in next iteration. So moving boundary left.
      while (boundary >= leftInclusive && arr[boundary] == pivot) {
        --boundary;
      }

      if (boundary <= leftInclusive) {
        return false;
      }
      //restart the process using last runningSum using the left section
      return canPartitionInPlace(arr, leftInclusive, boundary, runningSum, target);
    }

    return true;
  }

  /**
   * A solution with auxiliary data structure
   */
  boolean canPartition(int[] arr, int runningSum, int target) {
    if (arr.length == 0) {
      return false;
    }

    int sumWithPivot = 0;
    int pivot = arr[0];
    List<Integer> lowerSection = new ArrayList<>();
    List<Integer> higherSection = new ArrayList<>();
    for (int num : arr) {
      if (num < pivot) {
        sumWithPivot += num;
        lowerSection.add(num);
      } else if (num == pivot) {
        sumWithPivot += num;
      } else {
        higherSection.add(num);
      }
    }

    int newSum = runningSum + sumWithPivot;
    if (newSum == target) {
      return true;
    } else if (newSum < target) {
      int[] rightArray = new int[higherSection.size()];
      for (int i = 0; i < higherSection.size(); ++i) {
        rightArray[i] = higherSection.get(i);
      }
      return canPartition(rightArray, newSum, target);
    } else {
      int[] leftArray = new int[lowerSection.size()];
      for (int i = 0; i < lowerSection.size(); ++i) {
        leftArray[i] = lowerSection.get(i);
      }
      return canPartition(leftArray, runningSum, target);
    }
  }

  void swap(int[] arr, int a, int b) {
    if (a == b) {
      return;
    }

    int t = arr[a];
    arr[a] = arr[b];
    arr[b] = t;
  }
}

 

* A similar question in leetcode but without constraints on two sub-arrays: https://leetcode.com/problems/partition-equal-subset-sum/