几种常见的排序算法（C语言版）

最新推荐文章于 2023-07-15 14:36:42 发布

走进嵌入式

最新推荐文章于 2023-07-15 14:36:42 发布

阅读量394

点赞数 1

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

本文链接：https://blog.csdn.net/m0_57037805/article/details/127811370

版权

C 专栏收录该内容

14 篇文章 5 订阅

订阅专栏

一、插入排序

插入排序的思路：假设前面已经有i节点是有序的，那么就从第i+1个节点开始，插入到前面的i个节点的合适的位置中。由于第一个元素自身总是有序的，因此从第2个开始，不断插入前面的有序序列，直到全部排列完毕。

代码：

#include <stdio.h>

void sort(int *p)
{
    int num=0, sum=0, i=0, j=0;
    //计算个数
    while(*(p+i))
    {
        i++;
    }
    num = i - 1;
    //开始插入排序
    for ( i = 1; i < num ; i++)
    {
        sum = *(p+i);
        for (j = i-1; j >= 0; j--)
        {
            if (sum > *(p+j))
            {
                break;
            }
            else
            {
                *(p+(j+1)) = *(p+j);
            }
        } 
        *(p+(j+1)) = sum;
    }
    //排序后打印
    printf("排序后：");
    for ( i = 0; i < num; i++)
    {
        printf("%d  ",*(p+i));
    }
}

int main(void)
{
    int data[8] = {29,44,25,12,6,17,9,3};
    //调用插入排序函数
    sort(data);

    return 0;
}

结果：

二、冒泡排序

顺序：如果两个数据的位置符合排序的需要，则称它们是顺序的。
逆序：如果两个数据的位置不符合排序需要，则称它们是逆序的。

冒泡排序基于这样一种简单的思路：从头到尾让每两个相邻的元素进行比较，顺序就保持位置不变，逆序就交换位置。可以预料，经过一轮比较，序列中具有“极值”的数据，将被挪至序列的末端。

代码：

#include <stdio.h>

void sort(int *p)
{
    int num=0, sum=0, i=0, j=0;
    //计算个数
    while(*(p+i))
    {
        i++;
    }
    num = i - 1;
    //开始冒泡排序
    for ( i = 0; i < num-1 ; i++)
    {
        for (j = 0; j < num-i-1; j++)
        {
            if (*(p+j) > *(p+j+1))
            {
                sum = *(p+j);
                *(p+j) = *(p+j+1);
                *(p+j+1) = sum;
            }
        } 
    }
    //排序后打印
    printf("排序后：");
    for ( i = 0; i < num; i++)
    {
        printf("%d  ",*(p+i));
    }
}

int main(void)
{
    int data[8] = {29,44,25,12,6,17,9,3};
    //调用冒泡排序函数
    sort(data);

    return 0;
}

结果：

三、选择排序

选择排序的思路非常简单，就是依次从头到尾挑选合适的元素放到前面。

代码：

#include <stdio.h>

void sort(int *p)
{
    int num=0, sum=0, kum=0, i=0, j=0;
    //计算个数
    while(*(p+i))
    {
        i++;
    }
    num = i - 1;
    //开始选择排序
    for ( i = 0; i < num-1 ; i++)
    {
        sum = i;
        for (j = i+1; j < num; j++)
        {
            if (*(p+sum) > *(p+j))
            {
                sum = j;
            }
        } 

        kum = *(p+i);
        *(p+i) = *(p+sum);
        *(p+sum) = kum;
        
    }
    //排序后打印
    printf("排序后：");
    for ( i = 0; i < num; i++)
    {
        printf("%d  ",*(p+i));
    }
}

int main(void)
{
    int data[8] = {29,44,25,12,6,17,9,3};
    //调用选择排序函数
    sort(data);

    return 0;
}

结果：

四、快速排序

快速排序的基本思路是：在待排序序列中随便选取一个数据，作为所谓支点，然后所有其他的数据与之比较，以从小到大排序为例，那么比支点小的统统放在其左边，比支点大的统统放在其右边，就这样子递归下去，全部比较完退出。

代码：

#include <stdio.h>

void quicksort(int *p,int len);
void swap(int *a, int *b);
void display(int *arr, int len);

int main(void)
{
    int i, len;
    int arr[7];

    len = sizeof(arr)/sizeof(int);
    printf("请输入7个整数:\n");

    for(i=0; i<7; i++)
    {
        scanf("%d", &arr[i]);
    }

    printf("排序前数据:\n");
    display(arr, len);
    quicksort(arr, len);
    printf("排序后数据:\n");
    display(arr, len);
}

int partion(int *arr, int len)
{
    int i, j;

    if(len <= 1)
        return 0;

    i = 0;
    j = len-1;
    while(i < j)
    {
        //找到右边小于左边值，则退出
        while( arr[i] < arr[j] && i < j)
        {
             j--;
        }
        swap(&arr[i], &arr[j]);
        //找到左边大于右边值，则退出
        while( arr[i] <= arr[j] && i < j)
        {
            i++; 
        }   

        swap(&arr[i], &arr[j]);
    }
    //返回支点
    return i;
}

//快速排序
void quicksort(int *arr,int len)
{
    if(len <= 1)
        return;

    int pivot = partion(arr, len);
    quicksort(arr, pivot);
    quicksort(arr+pivot+1, len-pivot-1);
} 

//交换数据
void swap(int *a, int *b)
{
    int tmp;
    tmp = *a;
    *a = *b;
    *b = tmp;
}

//打印
void display(int *arr, int len)
{
    int i;
    for(i=0; i<len; i++)
    {
        printf("%d\t", arr[i]);
    }   
    printf("\n");
}

结果：

五、二分查找

二分査找也称折半査找，其优点是查找速度快，缺点是要求所要査找的数据必须是有序序列。该算法的基本思想是将所要査找的序列的中间位置的数据与所要査找的元素进行比较，如果相等，则表示査找成功，否则将以该位置为基准将所要査找的序列分为左右两部分。接下来根据所要査找序列的升降序规律及中间元素与所查找元素的大小关系，来选择所要査找元素可能存在的那部分序列，对其采用同样的方法进行査找，直至能够确定所要查找的元素是否存在。

代码：

#include <stdio.h>

//二分查找
int binarySearch(int *a, int n, int key)
{
    int low = 0;
    int high = n - 1;
    while(low <= high)
    {
        int mid = (low + high)/2;
        int midVal = *(a+mid);
        if(midVal<key)
            low = mid + 1;
        else if(midVal>key)
            high = mid - 1;
        else
            return mid;
    }
    return -1;
}

int main(){
    int i, val, ret;
    int a[8]={-32, 12, 16, 24, 36, 45, 59, 98};

    for(i=0; i<8; i++)
    {
        printf("%d\t", a[i]);
    }
    
    //用户输入
    printf("\n请输人所要查找的元素：");
    scanf("%d",&val);

    //调用二分查找得出结果
    ret = binarySearch(a,8,val);
    if(-1 == ret)
        printf("查找失败 \n");
    else
        printf ("查找成功 \n");
    return 0;
}

结果：