csTechie

  public static void findMinMax(int[]a)
  {
     int min = 99999;
     int max = -99999;
     int comp =0;
     for (int i = 0; i < a.length; i+=2)
     {
         int lmax,lmin;
         if(i+1==a.length)
         {
            lmax = a[i];
            lmin=a[i];
         }else{

           if(a[i] > a[i+1])
           {
              lmax=a[i];
              lmin=a[i+1];
           }else
           {
              lmax=a[i+1];
              lmin=a[i];
           }
         }
         if(max < lmax)max=lmax;
         if(min > lmin)min=lmin;

     }
     System.out.println("Max="+max+" Min="+min);

  }

public class QuickSort
{

  public static void swap(int[]a ,int i,int j)
  {
    int tmp = a[i];
    a[i]=a[j];
    a[j]=tmp;
  }

 // This logic will never give the location of the pivot element after the partition
  public static int partitionQuickSort(int[] a,int start,int end,int pivot)
  {
    int lo=start;
    int hi=end;
    int pivotVal = a[pivot];
    while(lo < = hi)
    {
      while(a[lo] < pivotVal)lo++;
      while(a[hi] > pivotVal)hi--;
      if(lo < = hi) {swap(a,lo,hi);
          lo++;
          hi--;
        }
    }
    return lo;
  }

  public static void quickSort(int[] inp,int start,int end)
  {
    if(start>=end)return;
    int mid = (start+end)/2;
    int loc = partitionQuickSort(inp,start,end,mid);
    if(loc-1 > start)    quickSort(inp,start,loc-1);
    if(end > loc)quickSort(inp,loc,end);
  }

    public static void printArray(int[] a)
  {
    for (int i = 0; i < a.length; i++)
    {
      System.out.print(a[i]+" ");
    }
    System.out.println();
  }

  /**
   *
   * @param args
   */
  public static void main(String[] args)
  {
    QuickSort quickSort = new QuickSort();
    int []inp = new int[]{9,8,5,6,2,2,2,2,3,4,7};
    quickSort(inp,0,inp.length-1);
    printArray(inp);
  }
}

  public static void  mirror(Node root)
  {
     if(root==null)return;
     Node left = root.left;
     mirror(root.left);
     mirror(root.right);
     root.left = root.right;
     root.right = left;
  }

  public static int getNthFibonacci(int n)
  {
    if(n==1)return 0;
    if(n==2)return 1;
    int a=0;
    int b=1;
    for (int i = 0; i < n-2 ; i++)
    {
       b = a+b;
       a = b -a;
      // System.out.println(b);
    }
    return b;
  }

class Activity implements Comparable
  {
    int start;
    int finish;

    public Activity(int x,int y)
    {
      start=x;
      finish=y;
    }

    public String toString()
    {
      return "[["+this.start+"-"+this.finish+"]]";
    }

    public int compareTo(Object obj)
    {
      Activity a = (Activity) obj;
      return this.finish - a.finish;
    }

  }

 public static ArrayList schedule(Activity [] list)
  {
    Arrays.sort(list);
    printActivityList(list);
    System.out.println();
    ArrayList ret = new ArrayList();
    ret.add(list[0]);
    int currentFinishTime = list[0].finish;
    for (int i = 1; i < list.length ; i++)
    {
       if(list[i].start > currentFinishTime)
       {
         //Add activity j to ret
         ret.add(list[i]);
         currentFinishTime = list[i].finish;
       }
    }
    return ret;
  }

   public static void printSpirally(int[][] a) {
        int N = a[0].length;
        for (int i = N - 1, j = 0; i > 0; i--, j++) {
            for (int k = j; k < i; k++)System.out.println(a[j][k]);
            for (int k = j; k < i; k++)System.out.println(a[k][i]);
            for (int k = i; k > j; k--)System.out.println(a[i][k]);
            for (int k = i; k > j; k--)System.out.println(a[k][j]);
        }
        int middle = (N / 2);
        if ((N % 2) == 1) {
            System.out.println(a[middle][middle]);
        }
    }

    public static boolean isVowel(char inp) {
        char c = Character.toUpperCase(inp);

        if ((c == 'A') || (c == 'E') || (c == 'I') || (c == 'O') || (c == 'U')) {
            return true;
        }

        return false;
    }

    public static void reverseVowels(char[] a) {
        int start = 0;
        int end = a.length - 1;

        while (start < end) {
            while ((start < a.length) && !isVowel(a[start])) {
                start++;
            }

            while ((end > 0) && !isVowel(a[end])) {
                end--;
            }

            if ((start > = end) || (start == a.length) || (end == -1)) {
                return;
            }

            //swap start and end;
            char t = a[start];
            a[start] = a[end];
            a[end] = t;
            start++;
            end--;
        }
    }

  public static void shuffle(int[] a)
  {
    int N = a.length;
    Random r = new Random(new Date().getTime());
    for (int i = 0; i < a.length-1; i++)
    {
       int tmp=0;
       // Find a random element from i to N-1
       int randElem = i + r.nextInt(N-i);
       //Replace randElem with current element
       tmp = a[i];a[i]=a[randElem];a[randElem]=tmp;
    }
  }

Find if the sum of two elements in a sorted array sum up to b (a number) with complexity of O(n).

  public static void find2ElementsOfSum(int[] a,int S)
  {
    int left = 0;
    int right = a.length-1;
    while(left < right)
    {
      int sum = a[left]+a[right];
      System.out.println("current Sum="+sum);
      if(sum==S){
       System.out.println("FOUND left="+left+" rigt="+right);
       return;
      }
      if(sum < S)
      {
        left++;
      }else
      {
        right--;
      }
    }
    System.out.println("NOT FOUND");
  }

Given an array of positive and negative numbers. Find the contiguous sub array of maximum sum.

   public static void subArraySum(int a[])
  {
    int i=0;
    int j=0;
    int start=0;
    int end=0;
    int maxSum = -99999;
    int cSum = 0;
    while(j < a.length)
    {
       cSum +=a[j];
       if(cSum>maxSum)// Set this as the new result
       {
          start=i;
          end = j;
          maxSum=cSum;
       }else if(cSum < 0)
       {
         cSum=0;
         i=j+1;
       }
       j++;
    }
    System.out.println("start="+start+" end="+end+" maxSum="+maxSum);

  }