排序总结归纳

对于一个int数组，请编写一个归并排序算法，对数组元素排序。

给定一个int数组A及数组的大小n，请返回排序后的数组。

测试样例：

[1,2,3,5,2,3],6

[1,2,2,3,3,5]

1、冒泡排序 O(n^2)

class BubbleSort {
public:
    int* bubbleSort(int* A, int n) {
        for(int i=0;i<n;i++){
            for(int j=i;j<n;j++){
                int tmp;
                if(A[i]>A[j]){
                    tmp = A[i];
                    A[i]= A[j];
                    A[j]= tmp;
                }
            }
        }
        return A; 
    }
};

2、归并排序 O(nlogn)

class MergeSort {
public:
    
    int* mergeSort(int* A, int n) {
        int* tmp = new int[n];
        mergeSort1(A,0,n-1,tmp);
        delete []tmp;
        return A;
    }
    void mergeSort1(int* A,const int first,const int last,int* tmp){
        if(first < last){
            int mid = (first + last) / 2;
            mergeSort1(A,first,mid,tmp);
            mergeSort1(A,mid+1,last,tmp);
            merge(A,first,mid,last,tmp);
        }
    }
    
    void merge(int* A,const int first,const int mid,const int last,int* tmp){
        int i=0,j=0,k=0;
        for(i=first,j=mid+1;i<=mid && j<= last;){
            if(A[i]<A[j]) 
                tmp[k++] = A[i++];
            else
                tmp[k++] = A[j++];
        }
        while(i<=mid) tmp[k++] = A[i++];
        while(j<=last) tmp[k++] = A[j++];
        for(i=0;i<k;i++){
            A[first+i] = tmp[i];
        }
        
    }
};

3、快速排序 O(nlogn)

class QuickSort {
public:
    int* quickSort(int* A, int n) {
        quickSort1(A,0,n-1);
        return A;
    }
    void quickSort1(int* A,const int first,const int last){
        if(first<last){
            int mid = Sort(A,first,last);
            quickSort1(A,first,mid);
            quickSort1(A,mid+1,last);
        }
    }
    int Sort(int* A,const int first,const int last){
        int i=first;
        int j=last;
        int key = A[first];
        if(first < last){
            while(i<j){
                while(i<j && key<=A[j])
                    j--;
                if(i<j)
                    A[i++] = A[j];
                while(i<j && key>=A[i])
                    i++;
                if(i<j)
                    A[j--] = A[i];
            }
            A[i] = key;
        }
        return i;
    }
};

 4、堆排序 O(nlogn)

class HeapSort {
public:
    int* heapSort(int* A, int n) {
        int len = n;
        for(int i=len/2-1;i>=0;i--)//bulid the heap
            heapAdjust(A,i,len);
        for(int i=len-1;i>=1;i--){// swap and adjust
            swap(A,0,i);
            heapAdjust(A,0,i);
        }
        return A;
    }
    void heapAdjust(int* A,int idx,int len){
        int left = 2*idx+1;
        int right = left+1;
        int largest = idx;
        
        if(left<len && A[left] > A[idx]) largest = left;
        if(right<len && A[right] > A[largest]) largest = right;
        if(largest != idx){
            swap(A,idx,largest);
            heapAdjust(A,largest,len);
        }
    }
    void swap(int* A,int a,int b){
        int tmp;
        tmp = A[a];
        A[a]= A[b];
        A[b]= tmp;
    }
};

 5、希尔排序

class ShellSort {
public:
    int* shellSort(int* A, int n) {
        for(int step=n/2;step>=1;step /= 2){
            for(int i=0;i<n;i+=step){
                int tmp = A[i];
                int j = i-step;
                for(;j>=0;j-=step){
                    if(A[j]>tmp)
                        A[j+step] = A[j];
                    else
                        break;
                }
                A[j+step] = tmp;
            }
        }
        return A;
    }
};