Interview Common Sample Codes

1. Quick Sort:

int partition(int A[], int p, int r)
{
    int x = A[r];　　// Pivot element
    int i = p - 1;　　// Index of last element that not larger than pivot element
    for(int j = p; j < r; ++j)
    {
        if(A[j] <= x)
        {
            ++i;
            exchange(A[i], A[j]);
        }
    }
     
    exchange(A[i+1], A[r]);
    return i+1;
}
 
void quickSort(int A[], int p, int r)
{
    if(p >= r)   return;
    int q = partition(A, p, r);
    quickSort(A, p, q - 1);
    quickSort(A, q + 1, r);
}

命名良好的Java版本：

public class Solution {
     
    public static void exchange(int[] nums, int a, int b) {
        if (a < 0 || b < 0 || a >= nums.length || b >= nums.length) {
            return;
        }
        int tmp = nums[a];
        nums[a] = nums[b];
        nums[b] = tmp;      
    }
     
    public static int partition(int[] nums, int left_pos, int right_pos) {
         
        int sentinel = nums[right_pos];
        int lst_less = left_pos - 1;
         
        for (int i = left_pos; i < right_pos; i++) {
            if (nums[i] < sentinel) {
                exchange(nums, ++lst_less, i);              
            }
        }
        exchange(nums, ++lst_less, right_pos);
         
        return lst_less;
    }
     
    public static void quickSort(int[] nums, int left_pos, int right_pos) {
        if (null == nums || nums.length < 2 ||
                left_pos >= right_pos ||
                left_pos < 0 || right_pos >= nums.length) {
            return;
        }
         
        int check_point = partition(nums, left_pos, right_pos);
        quickSort(nums, left_pos, check_point - 1);
        quickSort(nums, check_point + 1, right_pos);
    }
 
    public static void main(String[] args) {
         
        int[] res = {41, 12, 55, 7, 12, 13, 57};
        quickSort(res, 0, res.length - 1);
         
        for (int i : res) {
            System.out.println(i);
        }
         
    }
     
}

2. Search in Rotated Array:

class Solution {
    int comp(int A[], int s, int e, int target){
        if(s > e) return -1;
        if(s == e) return (A[s] == target ? s : -1);
         
        int mid = s + (e - s) / 2;
         
        if(A[mid] == target) 
            return mid;
        else if(A[mid] > target){
            // if first part is not rotated
            if(A[mid] >= A[s]){
                if(target >= A[s])
                    return comp(A, s, mid-1, target);
                else
                    return comp(A, mid+1, e, target);                
            }else{
                return comp(A, s, mid-1, target);
            }
        }else{
            // if first part is not rotated
            if(A[mid] >= A[s]){
                return comp(A, mid+1, e, target);
            }else{
                if(target <= A[e])
                    return comp(A, mid+1, e, target);
                else
                    return comp(A, s, mid-1, target);
            }
        }
    }
     
public:
    int search(int A[], int n, int target) {
        return comp(A, 0, n - 1, target);
    }
};

3. Maximum Subarray:

class Solution {
public:
    int maxSubArray(int A[], int n) {
        int dp = A[0];
        int end = dp;         
 
        for(int i = 1; i < n; ++i){
            end = end > 0 ? end + A[i] : A[i];
            dp = dp > end ? dp : end;
        }      
 
        return dp;
    }
};