LintCode 整数排序

class Solution {
public:
    /*
     * @param A: an integer array
     * @return: 
     */
    void sortIntegers(vector &A) {
        // write your code here
        //bubleSort(A);
        //selectionSort(A);
        //selectionSort1(A);
        //insertionSort(A);
        quickSort(A);
    }
    
private:
    // Quick sort
    int partition(vector &a, int left, int right) {
        if (left<0 || right<=0 || left>=right)
            return -1;
    
        int pivot = a[(left + right) / 2];
        while (left <= right) {
            // find the date at left side shift to right side
            while (left<=right && a[left]pivot)
                right--;
    
            // swap
            if (left <= right) {
                swap(a, left, right);
                left++;
                right--;
            }
        }
        return left;
    }
    
    void Qsort(vector &a, int left, int right) {
        if (left<0 || right<=0 || left>=right)
            return;
    
        int index = partition(a, left, right);
        if (left < index-1)
            Qsort(a, left, index-1);
        if (index < right)
            Qsort(a, index, right);
    }
    
    void quickSort(vector &a) {
        if (a.size() <= 1)
            return;
        Qsort(a, 0, a.size() - 1);
    }
    
    // Insertion Sort
    void insertionSort(vector &a) {
        for (int which=1; which < a.size(); which++) {
            int val = a[which];
            for (int i = 0; i < which; i++) {
                if (a[i] > val) {
                    // do shift to 
                    for (int j=which; j>i; j--) {
                        a[j] = a[j-1];
                    }
                    a[i] = val;
                    break;
                }
            }
        }
    }

    // Selection sort
    void swap(vector &a, int index1, int index2) {
        if (index1 == index2)
            return;
        auto it = a.begin();
        int temp = *(it + index1);
        *(it + index1) = *(it + index2);
        *(it + index2) = temp;        
    }
    
    int findSmallest(vector &a, int start, int end) {
        int min = start;
        for (int i = start + 1; i <= end; i++) {
            if (a[i] < a[min])
                min = i;
        }
        
        return min;
    }
    
    void selectionSort1(vector &a, int start, int end) {
        if (start < end - 1) {
            swap(a, start, findSmallest(a, start, end));
            selectionSort1(a, start + 1, end);
        }
    }
    
    void selectionSort1(vector &a) {
        if (a.size() <= 1)
            return;
    
        selectionSort1(a, 0, a.size() - 1);
    }

    // Selection sort
    void selectionSort(vector &a) {
        if (a.size() <= 1)
            return;
        
        for (int i = 0; i < a.size() - 1; i++) {
            int min = i;
            for (int j = i+1; j < a.size(); j++) {
                if (a[j] < a[min])
                    min = j;
            }
            
            if (min != i) {
                auto it = a.begin();
                int temp = *(it + min);
                *(it + min) = *(it + i);
                *(it + i) = temp;                
            }
        }
    }

    // buble sort
    void bubleSort(vector &a) {
        if (a.size() <=1)
            return;
        
        for (int i = 0; i < a.size(); i++) {
            for (int j = 1; j < a.size() - i; j++) {
                if (a[j] < a[j - 1]) {
                    auto it = a.begin();
                    int temp = *(it + j);
                    *(it + j) = *(it + j - 1);
                    *(it + j - 1) = temp;
                }
            }
        }    
    }
};