基础排序算法

Shimmer_ing

已于 2022-11-03 15:45:42 修改

阅读量190

点赞数 1

分类专栏：数据结构文章标签：排序算法算法数据结构

于 2022-10-02 09:11:24 首次发布

本文链接：https://blog.csdn.net/qq_46785243/article/details/127139919

版权

数据结构专栏收录该内容

16 篇文章 1 订阅

订阅专栏

排序算法

冒泡排序

比较相邻的元素，从小到大排序，如果第一个比第二个大，就交换他们两个。
把N个数通过N-1轮排序
外层循环i可以视为比较的趟数
内层循环j是每一趟需要比较的次数，每一趟都比前一次少一次

void bubble_sort(int arr[],int len){
    int temp,i,j;
    for (i = 0; i < len -1; i++){
        for (j = 0; j < len -1 -i; j++) {
            if(arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    } 
}

选择排序

第一次从待排序的数据元素中选出最小（或最大）的一个元素
存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素
然后放到已排序的序列的末尾

void selection_sort(int arr[],int len){
    int temp,i,j;
    for(i = 0; i < len; i++){ //每个元素都需要比较
        int minindex = i;  //假设未排序的第一位最小
        for(j = i + 1; j < len;j++){
            if(arr[j] < arr[minindex]){ //未排序的元素和最小的元素比较
               minindex = j;  //记下更小的序号
            }
        }
        //比较结束，当前序号的元素是未排序中最小的

        //交换位置，将最小的元素放到已排序列的后面
        temp = arr[minindex];
        arr[minindex] = arr[i];
        arr[i] = temp;
        
    }
    
}

插入排序

通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入
首先将第一个元素看作已经排好序，后面的元素（从第二个元素开始）依次和序列中元素比较，找到合适位置交换
第二个元素与第一个元素比较，比较后这两个元素成为排好序的序列
依次进行

void insert_sort(int *arr,int len)
{
     //由小到大排序
    int temp,i,j;
    for (i = 1; i < len; i++) //i = 0也可以，但在下面for循环不满足j > 0,直接跳过，因为第一个元素可以直接视为排好序
    {
        temp = arr[i]; //本轮比较元素
        for (j = i -1; j >=0 && temp < arr[j]; j--)
        { //如果 arr[i]<arr[j],意味着i上元素的位置仍要提前，因此将j的位置向后移一位
            arr[j+1] = arr[j]; 
        }
        arr[j+1] =temp;
    }
    
}

快速排序

从数列中取出一个数作为基准数，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。

算法思想

算法的实现类似挖坑填数
初始序列：72 6 57 88 73 48 85
72是pivot，low=0，high=7
第一轮：

        while (low < high && A[high] >= pivot) //从high开始比较，直到遇到小于pivot的数
            --high;                            //high就停在一个小于pivot的数上
        A[low] = A[high];

48 6 57 88 73 48 85
原来的72被换为48，low = 0 , high = 6

        while (low < high && A[low] <= pivot)  //开始从low开始寻找大于pivot的数
            ++low;
        A[high] = A[low]

48 6 57 88 73 88 85
high位置的48被换为88，low = 3 , high = 6

第二轮
high从第6位向左移动，移动到low所在的第3位时停止

while (low < high)

可见此时low = high = 3，且当前指向的值已经被存储在正确的位置

A[low] = pivot;

（ 48 6 57 ） 72 （73 88 85）
左右两侧均满足和pivot的大小关系，再对pivot左右继续递归quick sort

quick_sort(A, low, pivot - 1);
quick_sort(A, pivot + 1, high);

/*
快速排序

*/
int Partition(int A[], int low, int high)
{
    int pivot = A[low];  //选择第一个元素为pivot基准数
    while (low < high)   //循环条件
    {
        while (low < high && A[high] >= pivot) //从high开始比较，直到遇到小于pivot的数
            --high;                            //high就停在一个小于pivot的数上
        A[low] = A[high];                      //把high的数存到当前low的位置，由于这个low的数已经被存在pivot里因此不会丢失
        while (low < high && A[low] <= pivot)  //开始从low开始寻找大于pivot的数
            ++low;
        A[high] = A[low];                      //把high空出的位置赋给当前的low值
        
        //完成一次互换，继续下一轮比较
    }
    A[low] = pivot;                            //此时的high和low指向的是同一位置，此时位置上的值一定已经被存储在其他位置，并且满足左侧均比pivot小，右侧比pivot大
    return low;
}

void quick_sort(int A[], int low, int high)
{
    if (low < high)
    {
        int pivot = Partition(A, low, high); //递归调用，pivot左侧和右侧
        quick_sort(A, low, pivot - 1);
        quick_sort(A, pivot + 1, high);
    }
}

基数排序

从个位开始按照每个位数进行比较

举例

例：对A: { 2, 1, 34, 4 } 进行排序
对个位排序： 0 1 2 3 4
bucket： 0 1 1 0 2
bucket[ j - 1 ] + bucket[ j ] ： 0 1 2 2 4
倒序存放：A[3] = 4, A[2] = 34, A[0] = 1, A[1] = 2
bucket数组中存储的是个数
bucket[ j-1 ] + bucket[ j ] 得到的是位序

        for (j = n - 1; j >= 0; j--)
        { //倒序存放
            k = (arr[j] / radix) % 10;
            temp[bucket[k] - 1] = arr[j];
            bucket[k]--;
        }

A : 1 2 34 4 此时个位按照从小到大排列
对十位排序： 0 1 2
bucket： 3 0 1
bucket[ j - 1 ] + bucket[ j ] ： 3 3 4
倒序存放：A[2] = 4, A[4] = 34, A[1] = 2, A[0] = 1

 /*
基数排序
先根据个位进行排序，再按照排十位

*/
int temp[100];  //存放元素
int bucket[10]; //桶
void radix_sort(int arr[], int n)
{
    int d = 3; //最大位数，也可通过函数求出，这里默认为3
    int i, j, k;
    int radix = 1; //当前排序的位数
    for (i = 0; i < d; i++)
    {
        for (j = 0; j < 10; j++)
        {
            bucket[j] = 0; //清零
        }
        for (j = 0; j < n; j++)
        {
            k = (arr[j] / radix) % 10;
            bucket[k]++; //当前位数下，桶中元素的个数
        }

        /*************************************************************/

        for (j = 1; j < 10; j++)
        {
            bucket[j] = bucket[j - 1] + bucket[j]; //准备为下一步存放元素，告诉它们存放的位置
        }
        for (j = n - 1; j >= 0; j--)
        { //倒序存放
            k = (arr[j] / radix) % 10;
            temp[bucket[k] - 1] = arr[j];
            bucket[k]--;
        }
        //将排好的数组复制过来，准备下一次排序
        for (j = 0; j < n; j++)
        {
            arr[j] = temp[j];
        }
        //排序的位数改变
        radix *= 10;
    }
}

完整代码

#include <stdio.h>

/*
冒泡排序：比较相邻的元素，从小到大排序（从大到小反过来）。
如果第一个比第二个大，就交换他们两个。
把N个数通过N-1轮排序
外层循环i可以视为比较的趟数
内层循环j是每一趟需要比较的次数，每一趟都比前一次少一次
*/
void bubble_sort(int arr[], int len)
{
    int temp, i, j;
    for (i = 0; i < len - 1; i++)
    {
        for (j = 0; j < len - 1 - i; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

/*
选择排序：第一次从待排序的数据元素中选出最小（或最大）的一个元素
存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素
然后放到已排序的序列的末尾
*/
void selection_sort(int arr[], int len)
{
    int temp, i, j;
    for (i = 0; i < len; i++)
    {                     //每个元素都需要比较
        int minindex = i; //假设未排序的第一位最小
        for (j = i + 1; j < len; j++)
        {
            if (arr[j] < arr[minindex])
            {                 //未排序的元素和最小的元素比较
                minindex = j; //记下更小的序号
            }
        }
        //比较结束，当前序号的元素是未排序中最小的

        //交换位置，将最小的元素放到已排序列的后面
        temp = arr[minindex];
        arr[minindex] = arr[i];
        arr[i] = temp;
    }
}
/*
插入排序：通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入
首先将第一个元素看作已经排好序，后面的元素依次和序列中元素比较，找到合适位置交换
第二个元素与第一个元素比较，比较后这两个元素成为排好序的序列
依次进行
*/
void insert_sort(int arr[], int len)
{
    int temp, i, j;
    for (i = 1; i < len; i++) // i = 0也可以，但在下面for循环不满足j > 0,直接跳过，因为第一个元素可以直接视为排好序
    {
        temp = arr[i]; //本轮比较元素
        for (j = i - 1; j >= 0 && temp < arr[j]; j--)
        { // j=i-1因为第一个元素也要和后面的元素比较
            arr[j + 1] = arr[j];
        }
        arr[j + 1] = temp;
    }
}

/*
快速排序
算法的实现类似“挖坑填数”
72 6 57 88 73 48 85  72是pivot，low=0，high=7
第一轮 48 6 57 88 73 48 85
      48 6 57 88 73 88 85
此时A[low]=88(3),A[high]=88(6)
第二轮 high从第6位向左移动，移动到low所在的第3位时停止
可见此时low和high指向同一位置，且当前指向的值已经被存储在正确的位置
    （ 48 6 57 ）72 （73 88 85）
    左右两侧均满足和pivot的大小关系
    再对pivot左右继续递归quick sort
*/
int Partition(int A[], int low, int high)
{
    int pivot = A[low];  //选择第一个元素为pivot基准数
    while (low < high)   //循环条件
    {
        while (low < high && A[high] >= pivot) //从high开始比较，直到遇到小于pivot的数
            --high;                            //high就停在一个小于pivot的数上
        A[low] = A[high];                      //把high的数存到当前low的位置，由于这个low的数已经被存在pivot里因此不会丢失
        while (low < high && A[low] <= pivot)  //开始从low开始寻找大于pivot的数
            ++low;
        A[high] = A[low];                      //把high空出的位置赋给当前的low值
        
        //完成一次互换，继续下一轮比较
    }
    A[low] = pivot;                            //此时的high和low指向的是同一位置，此时位置上的值一定已经被存储在其他位置，并且满足左侧均比pivot小，右侧比pivot大
    return low;
}

void quick_sort(int A[], int low, int high)
{
    if (low < high)
    {
        int pivot = Partition(A, low, high); //递归调用，pivot左侧和右侧
        quick_sort(A, low, pivot - 1);
        quick_sort(A, pivot + 1, high);
    }
}

/*
基数排序
先根据个位进行排序，再按照排十位
*/
int temp[100];  //存放元素
int bucket[10]; //桶
void radix_sort(int arr[], int n)
{
    int d = 3; //最大位数，也可通过函数求出
    int i, j, k;
    int radix = 1; //当前排序的位数
    for (i = 0; i < d; i++)
    {
        for (j = 0; j < 10; j++)
        {
            bucket[j] = 0; //清零
        }
        for (j = 0; j < n; j++)
        {
            k = (arr[j] / radix) % 10;
            bucket[k]++; //当前位数下，桶中元素的个数
        }

        /*************************************************************/

        for (j = 1; j < 10; j++)
        {
            bucket[j] = bucket[j - 1] + bucket[j]; //准备为下一步存放元素，告诉它们存放的位置
        }
        for (j = n - 1; j >= 0; j--)
        { //倒序存放
            k = (arr[j] / radix) % 10;
            temp[bucket[k] - 1] = arr[j];
            bucket[k]--;
        }
        //将排好的数组复制过来，准备下一次排序
        for (j = 0; j < n; j++)
        {
            arr[j] = temp[j];
        }
        //排序的位数改变
        radix *= 10;
    }
}

int main()
{
    int arr[] = {22, 34, 3, 32, 82, 55, 189, 50};
    // bubble_sort(arr,8);
    // selection_sort(arr,8);
    // insert_sort(arr, 8);
    // quick_sort(arr, 0, 7);
    radix_sort(arr, 8);
    int i;
    for (i = 0; i < 8; i++)
        printf("%d ", arr[i]);
    return 0;
}