十大经典排序算法

1.冒泡排序

实现冒泡排序算法，并将乱序数列变成升序。

 /********** Begin *********/
    int temp;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<n-i-1;j++)
        {
            if(arr[j]>arr[j+1])
            {
                temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
           if(i==n-1||i==0||i==2||i==1)
           print_array(arr,n);
    }
    
    
    /********** End **********/

2.选择排序

实现选择排序算法，并将乱序数列变成升序。

/********** Begin *********/
    int len = n;
    int minIndex, temp;
    for (int i = 0; i < len - 1; i++) {
        minIndex = i;
        for (int j = i + 1; j < len; j++) {
            if (arr[j] < arr[minIndex]) {     // 寻找最小的数
                minIndex = j;                 // 将最小数的索引保存
            }
        }
        temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
        if (i < 3)print_array(arr, n);
    }
    print_array(arr, n);
    /********** End **********/

3.插入排序

实现插入排序算法，并将乱序数列变成升序

/********** Begin *********/
    int i,j;
    int temp;
    for(i=0;i<n-1;i++)
    {
        temp=arr[i+1];
        j=i;
        while(j>-1&&temp<arr[j])
        {
            arr[j+1]=arr[j];
            j--;
        }
        arr[j+1]=temp;
        if (i < 3)print_array(arr, n);
    }
    print_array(arr,n);

    
    /********** End **********/

4.希尔排序

实现希尔排序算法，并将乱序数列变成升序。

/********** Begin *********/
    int i,j,m=0;
    for(int gap = 5; gap > 0; gap /= 2) 
    {
        for(i = gap; i < n; i++) 
        {
            int num = arr[i];
            for(j = i-gap; j>=0 && arr[j]>num; j-=gap)
                arr[j+gap] = arr[j];
            arr[j+gap] = num;
        }
        if(m<3)
        {
            print_array(arr,  n);
            m++;
        }
    }
    print_array(arr,  n);
    /********** End **********/

5.归并排序

实现归并排序算法，并将乱序数列变成升序。

/********** Begin *********/
    int* res;
    res = new int[n1 + n2];
    int a1 = 0, a2 = 0;
    int index = 0;

    for (int i = 0; i < n1+n2; i++) {
        if (i < n1) {
            res[i] = arr1[i];
        }
        else {
            res[i] = arr2[i - n1];
        }
    }

    sort(res, res + n1 + n2);

    return res;
    
    /********** End **********/
}
int* merge_sort(int *arr, int n)
//  基于merge_array函数编程实现归并排序：自上而下的递归方法
//  函数参数：有序数组arr 数组arr长度
//  函数返回值：返回从小到大排序后的数组
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int mid = n / 2;
    if (mid > 0) {
        int* arr1 = new int[mid];
        int n1 = mid;
        int n2 = n - mid;
        int* arr2 = new int[n2];
        for (int i = 0; i < n; i++) {
            if (i < mid) {
                arr1[i] = arr[i];
            }
            else {
                arr2[i - mid] = arr[i];
            }
        }

        merge_sort(arr1, n1);   
        merge_sort(arr2, n - mid);     
        merge_array(arr1, n1, arr2, n2);
    }
    else
    {
        return  merge_array(arr, n, NULL, 0);
    }
    
    /********** End **********/

6.快速排序

实现快速排序算法，并将乱序数列变成升序。

 /********** Begin *********/
    int a = arr[l];
    int q = l;
    int e = r;
    while(q != e){
        while(e > q && arr[e]>= a){
            e--;
        }
        while(e > q && arr[q] <= a){
            q++;
        }
        if(q < e){
            swap(arr[q],arr[e]);
        }
    }
    arr[l]= arr[q];
    arr[q] = a;
    return q;
    /********** End **********/
}

int* quick_sort(int *arr, int l, int r)
//  基于partition_array函数编程实现快速排序：自上而下的递归方法
//  函数参数：有序数组arr 初始l=0，r=n-1
//  函数返回值：返回从小到大排序后的数组
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    if(l<r){
        int a = partition_array(arr ,l,r);
        quick_sort(arr,l , a);
        quick_sort(arr, a+1, r);
        return arr;
    }

    /********** End **********/

7.堆排序

实现堆排序算法，并将乱序数列变成升序

/********** Begin *********/
    int a = arr[param1]; 
    int child = 2*param1 + 1; 

    while(child < j){
        if(child + 1 < j && arr[child] < arr[child+1 ]){
            child++;
        }

        if(a >= arr[child]){
            break;
        }

        arr[param1] = arr[child];

        param1 = child;
        child = 2*child +1;
    }
    arr[param1] = a;

    /********** End **********/
}

int* heap_sort(int *arr, int n)
//  基于adjustHeap函数编程实现堆排序
//  函数参数：无序数组arr 数组长度n
//  函数返回值：返回从小到大排序后的数组
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    for(int i=n/2 - 1;i>=0;i--){
        adjustHeap(arr,i, n);
    }

    for(int i = n-1;i>0;i--){
        swap(arr[0],arr[i]);
        adjustHeap(arr,0, i);
    }
    return arr;
    /********** End **********/

8.技术排序

实现计数排序算法，并将乱序数列变成升序。

/********** Begin *********/
    int max=0;
    int s;
    for(s=0;s<n;s++)
    {
        if(max<arr[s])
        {
            max=arr[s];
        }
    }
    int min=99;
    for(s=0;s<n;s++)
    {
        if(min>arr[s])
        {
            min=arr[s];
        }
    }
    int arrLen = max-min+1;
    int *jishu = new int[arrLen];

    fill(jishu,jishu+arrLen,0);

    for(int i=0;i<n;i++){
        jishu[arr[i]-min] += 1;
    }
    int index = 0;

    for(int i=0;i<arrLen;i++){
        if(jishu[i]!= 0){
            printf("%d %d\n", i+min,jishu[i]);
        }
    }

    for(int i=0;i<arrLen;i++)
    {
        while(jishu[i] != 0){
            arr[index] = i+min;
            jishu[i]--;
            index++;
        }
    }
    print_array(arr,n);
    /********** End **********/

9.桶排序

实现桶排序算法，并将乱序数列变成升序。

/********** Begin *********/
    int max=0;
    int s;
    for(s=0;s<n;s++)
    {
        if(max<arr[s])
        {
            max=arr[s];
        }
    }
    int min=99;
    for(s=0;s<n;s++)
    {
        if(min>arr[s])
        {
            min=arr[s];
        }
    }
    int bucketNum = (max-min)/n + 1;
    int *bucket = new int[bucketNum*n];
    int *bucketIndex = new int[bucketNum];
    fill(bucketIndex,bucketIndex+bucketNum,-1);

    for(int i=0;i<n;i++){
        int index = arr[i]/(n+1);
        bucketIndex[index]++;
        bucket[index*n+bucketIndex[index]] = arr[i];
    }

    for(int i=0;i<bucketNum;i++){
        if(bucketIndex[i]!= -1){
            sort(bucket+i*n,bucket +i*n +bucketIndex[i]+1);
        }
    }
    int index = 0;
    for(int i=0;i<bucketNum;i++){
        int a = 0;
        while(bucketIndex[i]>=0){
            arr[index] = bucket[i*n + a];
            a++;
            index++;
            bucketIndex[i]--;
        }
    }
    return arr;
    
    /********** End **********/

10.基数排序

实现基数排序算法，并将乱序数列变成升序。

/********** Begin *********/
    int max=0;
    int s;
    for(s=0;s<n;s++)
    {
        if(max<arr[s])
        {
            max=arr[s];
        }
    }
    int *radix = new int[n*10];
    fill(radix,radix+n*10,0);
    int *tmparr = new int[n];
    for(int i=0;i<n;i++){
        tmparr[i] = arr[i];
    }

    int jishu[10];
    fill(jishu,jishu+10,-1);

    int wei = 0;
    while(max>0){
        max /= 10;
        wei ++;
    }
    for(int i=1;i<=wei;i++){

        int dev = 1;
        for(int j=1;j<i;j++){
            dev *= 10;
        }
        for(int j=0;j<n;j++){

            int index = arr[j]/(dev)%(10);
            jishu[index]++;
            radix[index*n + jishu[index]] = arr[j];
        }
        int ind = 0;
        for(int k=0;k<10;k++){
            
            if(jishu[k]>=0){
                sort(radix + k*n,radix + k*n + jishu[k]+1);
                for(int j=0;j<jishu[k]+1;j++){
                    arr[ind] = radix[k*n+j];
                    ind ++;
                }
                jishu[k] = -1;
            }
        }
        fill(radix,radix+n*10,0);
    }
    return arr;
    
    /********** End **********/