整数排序-未完待续

给一组整数，按照升序排序，使用选择排序，冒泡排序，插入排序或者任何 O(n2) 的排序算法。

（1）冒泡排序，重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

    void sortIntegers(vector<int>& A) {
        int tmp = 0;
        int N = A.size();
        int i,j;
        for(i=0; i<N-1; i++) {
            for(j=i+1; j<N; j++) {
                if(A[i]>A[j]) {
                    tmp = A[i];
                    A[i] = A[j];
                    A[j] = tmp;
                }
            }
        }
    } 

（2）选择排序， 每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

        int tmp = 0;
        int N = A.size();
        int i,j, index_min;
        for(i=0; i<N-1; i++) {
            index_min = i;
            for(j=i+1; j<N; j++) {
                if(A[index_min]>A[j]) {
                    index_min=j;
                }
            }
            if(index_min != i) {
                tmp = A[i];
                A[i] = A[index_min];
                A[index_min] = tmp;
            }
        }
    }

（3）直接插入排序， 把待排序的纪录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的纪录插入完为止，得到一个新的有序序列。

    void sortIntegers(vector<int>& A) {
        int tmp = 0;
        int N = A.size();
        int i,j, flag_j, insert_tmp;
        if(A[0]>A[1]) {
            tmp = A[0];
            A[0] = A[1];
            A[1] = tmp;
        }
        for(i=2; i<=N-1; i++) {
            insert_tmp = A[i];
            flag_j = i;
            for(j=i-1; j>=0; j--) {
                if(A[j]>=insert_tmp) {
                    A[j+1] = A[j];
                    flag_j = j;
                }
            }
            if(flag_j!=i) {
                A[flag_j] = insert_tmp;
            } 
        }
    }