数据结构-十大经典排序算法

2022.12.30发完数据结构就告一段落，22年也尽快过去，疫情也退散了，预祝各位元旦快乐！

---

冒泡排序

//
//  sort_.cpp
//  Sort
//
//  Created by ljpc on 2018/4/20.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "sort_.h"

void print_array(int *arr, int n)
// 打印数组
{
    if(n==0)
    {
        printf("ERROR: Array length is ZERO\n");
        return;
    }
    printf("%d", arr[0]);
    for (int i=1; i<n; i++)
    {
        printf(" %d", arr[i]);
    }
    printf("\n");
}



void sort_array(int *arr, int n)
//  编程实现《冒泡排序算法》：将乱序序列arr转化为升序序列
//  函数参数：乱序整数数组arr 数组长度
//  要求输出：调用print_array(int *arr, int n)输出前三次冒泡操作后的序列，以及最终的升序序列
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int i,x,j;
    for(j=0; j<n-1; j++)
    {
        for(i=0; i<n-j-1; i++)
        {
            if(arr[i]>arr[i+1])
            {
                x=arr[i];
                arr[i]=arr[i+1];
                arr[i+1]=x;
            }
        }
        if(j<3) print_array(arr,n);
    }
    print_array(arr,n);
    /********** End **********/
}

选择排序

//
//  sort_.cpp
//  Sort
//
//  Created by ljpc on 2018/4/20.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "sort_.h"

void print_array(int *arr, int n)
// 打印数组
{
    if(n==0)
    {
        printf("ERROR: Array length is ZERO\n");
        return;
    }
    printf("%d", arr[0]);
    for (int i=1; i<n; i++)
    {
        printf(" %d", arr[i]);
    }
    printf("\n");
}

void sort_array(int *arr, int n)
//  编程实现《选择排序算法》：将乱序序列arr转化为升序序列
//  函数参数：乱序整数数组（无重复元素） 数组长度
//  要求输出：调用print_array(int *arr, int n)输出前三次选择操作后的序列，以及最终的升序序列
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int i,j,x,t;
    for(j=0; j<n-1; j++)
    {
        x=j;
        for(i=j+1; i<n; i++)
        {
            if(arr[i]<arr[x]) x=i;
        }
        t=arr[x];
        arr[x]=arr[j];
        arr[j]=t;
        if(j<3) print_array(arr,n);
    }
    print_array(arr,n);
    /********** End **********/
}

插入排序

//
//  sort_.cpp
//  Sort
//
//  Created by ljpc on 2018/4/20.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "sort_.h"

void print_array(int *arr, int n)
// 打印数组
{
    if(n==0)
    {
        printf("ERROR: Array length is ZERO\n");
        return;
    }
    printf("%d", arr[0]);
    for (int i=1; i<n; i++)
    {
        printf(" %d", arr[i]);
    }
    printf("\n");
}

void sort_array(int *arr, int n)
//  编程实现《插入排序算法》：将乱序序列arr转化为升序序列
//  函数参数：乱序整数数组（无重复元素） 数组长度
//  要求输出：调用print_array(int *arr, int n)输出前三次插入操作后的序列，以及最终的升序序列
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int i,j,x;
    for(i=0; i<n-1; i++)
    {
        x=arr[i+1];
        j=i;
        while(x<arr[j]&&j>-1)
        {
            arr[j+1]=arr[j];
            j--;
        }
        arr[j+1]=x;
        if(i<3) print_array(arr,n);
    }
    print_array(arr,n);
    /********** End **********/
}

希尔排序

//
//  sort_.cpp
//  Sort
//
//  Created by ljpc on 2018/4/20.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "sort_.h"

void print_array(int *arr, int n)
// 打印数组
{
    if(n==0)
    {
        printf("ERROR: Array length is ZERO\n");
        return;
    }
    printf("%d", arr[0]);
    for (int i=1; i<n; i++)
    {
        printf(" %d", arr[i]);
    }
    printf("\n");
}

void sort_array(int *arr, int n)
//  编程实现《希尔排序算法》：将乱序序列arr转化为升序序列
//  函数参数：乱序整数数组 数组长度
//  要求输出：调用print_array(int *arr, int n)输出三遍增量排序操作后的序列，以及最终的升序序列
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int i = 0,t=0;
    int key = 0;
    int end = 0;
    int Gap[4] = {5,2,1,-1};
    int gap = Gap[t];
    while (gap > 0)
    {
        for (i = gap; i < n; i++)
        {
            key = arr[i];
            end = i - gap;
            while (end >= 0 && key<arr[end])
            {
                arr[end + gap] = arr[end];
                end=end-gap;
            }
            arr[end + gap] = key;
        }
        print_array(arr, n);
        t++;
        gap=Gap[t];
    }
    print_array(arr, n);
    /********** End **********/
}

归并排序

//
//  sort_.cpp
//  Sort
//
//  Created by ljpc on 2018/4/20.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "sort_.h"

void print_array(int *arr, int n)
// 打印数组
{
    if(n==0){
        printf("ERROR: Array length is ZERO\n");
        return;
    }
    printf("%d", arr[0]);
    for (int i=1; i<n; i++) {
        printf(" %d", arr[i]);
    }
    printf("\n");
}

int* merge_array(int *arr1, int n1, int* arr2, int n2)
//  编程实现两个有序数组arr1和arr2合并
//  函数参数：有序数组arr1 数组arr1长度 有序数组arr2 数组arr2长度
//  函数返回值：返回从小到大排序后的合并数组
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
	int arr3_length =  n1 + n2;
    int *arr3 = (int *)malloc(sizeof(int)*arr3_length);
	int i=0 , j=0,t=0;
	while(i<n1&&j<n2)
		{
			if(arr1[i]<=arr2[j])
				arr3[t++] = arr1[i++];
			else
				arr3[t++] = arr2[j++];	
		}
	if(i==n1)
		{
			while(t<arr3_length)
				arr3[t++] = arr2[j++];	
		}
	else
		{
			while(t<arr3_length)
			arr3[t++] = arr1[i++];
		}
	return arr3;
    /********** End **********/
}
int* merge_sort(int *arr, int n)
//  基于merge_array函数编程实现归并排序：自上而下的递归方法
//  函数参数：有序数组arr 数组arr长度
//  函数返回值：返回从小到大排序后的数组
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int mid ;
    int left = 0 ,right = n;
	mid = (left+right)/2;
    if(right!=1)
    {
        int *Arr_1 = &arr[left],*Arr_2 = &arr[mid];
        Arr_1 = merge_sort(Arr_1,mid);
        Arr_2 = merge_sort(Arr_2,right-mid);
        arr = merge_array(Arr_1,mid,Arr_2,right-mid);
    }
    return arr;
    /********** End **********/
}

快速排序

//
//  sort_.cpp
//  Sort
//
//  Created by ljpc on 2018/4/20.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "sort_.h"

void print_array(int *arr, int n)
// 打印数组
{
    if(n==0){
        printf("ERROR: Array length is ZERO\n");
        return;
    }
    printf("%d", arr[0]);
    for (int i=1; i<n; i++) {
        printf(" %d", arr[i]);
    }
    printf("\n");
}

int partition_array(int *arr ,int l,int r)
// 编程实现arr[l, r]分区：选定一个基准，左边比基准小，右边比基准大
// 返回基准所处位置
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
     int pivot = arr[l];
    int i = l + 1;
    int j = r;
    while (i <= j)
    {
        while (i <= r && arr[i] <= pivot)
        {
            i++;
        }
        while (j >= l + 1 && arr[j] >= pivot)
        {
            j--;
        }
        if (i < j)
        {
            swap(arr[i], arr[j]);
        }
    }
    swap(arr[l], arr[j]);
    return j;
    /********** End **********/
}

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

堆排序

//
//  sort_.cpp
//  Sort
//
//  Created by ljpc on 2018/4/20.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "sort_.h"

void print_array(int *arr, int n)
// 打印数组
{
    if(n==0)
    {
        printf("ERROR: Array length is ZERO\n");
        return;
    }
    printf("%d", arr[0]);
    for (int i=1; i<n; i++)
    {
        printf(" %d", arr[i]);
    }
    printf("\n");
}

void adjustHeap(int *arr, int param1, int j)
// 编程实现堆的调整
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int temp = arr[param1];
    int child = 2*param1 + 1;
    while(child < j)
    {
        if(child + 1 < j && arr[child] < arr[child+1 ])
        {
            child++;
        }
        if(temp >= arr[child])
        {
            break;
        }
        arr[param1] = arr[child];
        param1 = child;
        child = 2*child +1;
    }
    arr[param1] = temp;
    /********** 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 **********/
}

计数排序

//
//  sort_.cpp
//  Sort
//
//  Created by ljpc on 2018/4/20.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "sort_.h"

void print_array(int *arr, int n)
// 打印数组
{
    if(n==0)
    {
        printf("ERROR: Array length is ZERO\n");
        return;
    }
    printf("%d", arr[0]);
    for (int i=1; i<n; i++)
    {
        printf(" %d", arr[i]);
    }
    printf("\n");
}


void sort_array(int *arr, int n)
//  编程实现《计数排序算法》
//  函数参数：乱序整数数组 数组长度
//  要求输出：调用print_array(int *arr, int n)输出：
//  每一行一个元素及其个数（升序），如 1 1
//  以及最终的升序序列
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int max = *max_element(arr,arr+n);
    int min = *min_element(arr,arr+n);
    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 **********/
}

桶排序

//
//  sort_.cpp
//  Sort
//
//  Created by ljpc on 2018/4/20.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "sort_.h"

void print_array(int *arr, int n)
// 打印数组
{
    if(n==0)
    {
        printf("ERROR: Array length is ZERO\n");
        return;
    }
    printf("%d", arr[0]);
    for (int i=1; i<n; i++)
    {
        printf(" %d", arr[i]);
    }
    printf("\n");
}


int* sort_array(int *arr, int n)
//  编程实现《桶排序算法》
//  函数参数：乱序整数数组 数组长度
//  函数返回值：返回从小到大排序后的数组
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int maxVal = arr[0];
    for(int i = 1; i < n; i++)
    {
        if(arr[i] > maxVal)
            maxVal = arr[i];
    }
    int tmpArrLen = maxVal + 1;
    int tmpArr[tmpArrLen];
    int i, j;
    for( i = 0; i < tmpArrLen; i++)
        tmpArr[i] = 0;
    for(i = 0; i < n; i++)
        tmpArr[ arr[i] ]++;
    for(i = 0, j = 0; i < tmpArrLen; i ++)
    {
        while( tmpArr[ i ] != 0)
        {
            arr[j ] = i;
            j++;
            tmpArr[i]--;
        }
    }
    return arr;
    /********** End **********/
}

基数排序

//
//  sort_.cpp
//  Sort
//
//  Created by ljpc on 2018/4/20.
//  Copyright © 2018年 ljpc. All rights reserved.
//

#include "sort_.h"

void print_array(int *arr, int n)
// 打印数组
{
    if(n==0){
        printf("ERROR: Array length is ZERO\n");
        return;
    }
    printf("%d", arr[0]);
    for (int i=1; i<n; i++) {
        printf(" %d", arr[i]);
    }
    printf("\n");
}


int* sort_array(int *arr, int n)
//  编程实现《基数排序算法》
//  函数参数：乱序整数数组 数组长度
//  函数返回值：返回从小到大排序后的数组
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int temp[10][n]= {0};
    int order[n]= {0};
    int i,j,k;
    int t;
    int p;
    t=1;
    while(t <= 100)
    {
        for(i=0; i<n; i++)
        {
            k = (arr[i]/t) % 10;
            temp[k][order[k]] = arr[i];
            order[k]++;
        }
        p=0;
        for(i=0; i<n; i++)
        {
            if(order[i] != 0)
            {
                for(j=0; j<order[i]; j++)
                {
                    arr[p] = temp[i][j];
                    p++;
                }
                order[i] = 0;
            }
        }
        t *= 10;
    }
    return arr;
    /********** End **********/
}