排序模板

今天趁机会自己总结了一下排序模板，以后用着方便些，少的以后再补充。

/*排序模板，该模板均按照增序处理*/

0.冒泡排序

/*增序冒泡，O(N^2)*/
void Bubble_sort(T* arr,int len){
    if( len <= 0 ){
        return ;
    }
    for( int i = 0; i < len-1; i++ ){
        for( int j = 0; j < len-i-1; j++ ){
            if( arr[j] > arr[j+1] ){
                T tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
            }
        }
    }
    return ;
}

1.插入排序

/*增序插入，O(N^2)*/
void Insert_sort(T* arr,int len){
    for( int i = 0; i < len; i++ ){
        for( int j = i-1; j>=0 && arr[j]>arr[i] ; j-- ){
            arr[j+1] = arr[j];
        }
        arr[j+1]=arr[i];
    }
    return ;
}

2.选择排序

/*选择排序，O(N^2)*/
void Select_sort(T* arr,int len){
    for( int i = 0; i < len; i++ ){
        int pos = i;
        int minNum = -INF;
        for( int j = i; j < len; j++ ){
            if( arr[j] < minNum ){
                minNum = arr[j];
                pos = j;
            }
        }
        swap(arr[pos],arr[i]);
    }
}

3.希尔排序

/*增序希尔，O(N(logN)^2)*/
void Shell_sort(T* arr,int len){
    if( left >= right ){
        return ;
    }
    for( int delta = len/2; delta > 0; delta/=2 ){
        for( int i = delta; i < len; i++ ){
            T tmp = arr[i];
            int j;
            for( j = i-delta; j>=0 && tmp<arr[j]; j-= delta ){
                arr[j+delta] = arr[j];
            }
            arr[j+delta] = tmp;
        }
    }
}

4.快排

/*增序快排，O(NlogN)*/
void Quick_sort(T* arr,int left,int right){
    if( left < right ){
        int i = left;
        int j = right;
        T tmp = arr[i];
        while( i < j ){
            while( i<j && arr[j]>=tmp ){
                j--;
            }
            if( i<j ){
                arr[i++] = arr[j];
            }
            while( i<j && arr[i]<=tmp ){
                i++;
            }
            if( i<j ){
                arr[j--] = arr[i];
            }
        }
        arr[i] = tmp;
        Quick_sort(arr,left,i-1);
        Quick_sort(arr,i+1,right);
    }
    return ;
}

5.归并排序

/*增序归并，O(NlogN)*/
void Merge(T* arr,int left,int mid,int right){
    int i = left;
    int j = mid+1;
    int k = 0;
    T* tmp = new T[right-left+1];
    while( i<=mid && j<=right ){
        if( arr[i] <= arr[j] ){
            tmp[k++] = arr[i++];
        }
        else{
            tmp[k++] = arr[j++];
        }
    }
    while( i <= mid ){
        tmp[k++] = arr[i++];
    }
    while( j <= right ){
        tmp[k++] = arr[j++];
    }
    for( i = left,k = 0; i <= right; i++ ){
        arr[i] = tmp[k++];
    }
    delete []tmp;
}
void Merge_sort(T* arr,int left,int right){
    int mid;
    if( left < right ){
        mid = (left+right)>>1;
        Merge_sort(arr,left,mid);
        Merge_sort(arr,mid+1,right);
        Merge(arr,left,mid,right);
    }
}

6.堆排序

/*增序堆排，O(NlogN)*/
void Stack_shift(T* arr,int low,int high){
    int i = low;
    int j = 2*i+1;
    T tmp = arr[i];
    while( j <= high ){
        if( j<high && arr[j]<arr[j+1] ){
            j++;
        }
        if( tmp < arr[j] ){
            arr[i] = arr[j];
            i = j;
            j = 2*i+1;
        }
        else{
            break;
        }
    }
    arr[i] = tmp;
}
void Stack_sort(T* arr,int len){
    for( int i = len/2-1; i >= 0; i-- ){
        Stack_shift(arr,i,len-1);
    }
    for( int i = len-1; i > 0; i-- ){
        T tmp = arr[0];
        arr[0] = arr[i];
        arr[i] = tmp;
        Stack_shift(arr,0,i-1);
    }
    return ;
}