排序算法总结

最新推荐文章于 2024-09-20 17:57:51 发布
原创 最新推荐文章于 2024-09-20 17:57:51 发布 · 595 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#排序算法

本文详细介绍了多种排序算法的实现，包括冒泡排序、选择排序、插入排序、希尔排序、堆排序、归并排序和快速排序等。每种算法都有详细的解释及其实现代码。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

这里写图片描述
下面是算法实现，对于堆排序没有怎么调试，其他的都调试过了

#include <stdio.h>

#define maxsize 10

typedef enum
{
    true = 1,
    false = 0
}Status;

typedef struct
{
    int r[maxsize];
}Sqlist;


void swap(Sqlist *L, int i, int j);

void data_get(Sqlist *L);
void data_print(Sqlist *L);

void bubble_sort0(Sqlist *L);
void bubble_sort1(Sqlist *L);
void bubble_sort2(Sqlist *L);

void select_sort(Sqlist *L);
void insert_sort(Sqlist *L);
void shell_sort(Sqlist *L);

void Heapsort(Sqlist *L);
void HeapAdjust(Sqlist *L, int m, int n);


void Merge_Sort(Sqlist *L);
void M_Sort(int SR[], int TR1[], int s, int t);
void Merge(int SR[], int TR[], int i, int m, int n);


void Quicksort(Sqlist *L);
void QSort(Sqlist *L, int low, int high);
int Partion(Sqlist *L, int low, int high);



int main( )
{
    Sqlist L;

    data_get(&L);

    Merge_Sort(&L);

    data_print(&L);

    return 0;
}

/**********************************交换排序*****************************************/

/*
    交换排序的基本思想是：两两比较相邻记录的关键字，
    如果反序则交换，直到没有反序为止。
*/

void bubble_sort0(Sqlist *L)
{
    int i, j;
    for(i=0; i<maxsize; i++)
        for(j=i; j<maxsize; j++)
        {
            if(L->r[i] > L->r[j])
                swap(L, i, j);
        }
}

/**********************************冒泡排序****************************************/

/*
    冒泡排序的基本思想是：第二层循环 j-1和j做对比，
    大则交换,也就是临近的两两做交换
*/
void bubble_sort1(Sqlist *L)
{
    int i, j;

    for(i=0; i<(maxsize-1); i++)
        for(j=0; j<(maxsize-1-i); j++)
        {
            if(L->r[j] > L->r[j+1])
                swap(L, j+1, j);
        }
}

/*
冒泡排序改进：几乎与上面的相同，主要目的是除去多余的遍历操作,
也就是说发现，已经排好序了，就不需要后面的遍历了
*/
void bubble_sort2(Sqlist *L)
{
    int i, j;

    Status flag = true;

    for(i=1; i<maxsize && flag; i++)
    {
        for(j=maxsize-1; j>=i; j--)
        {
            flag =false;
            if(L->r[j-1] > L->r[j])
            {
                swap(L, j-1, j);
                flag = true;            
            }
        }
    }
}

/**********************************简单选择排序*************************************/
/*
    简单选择排序的基本思想是：通过n-i次关键字间的比较，
    从n-i+1个记录中选出关键字最小的记录，   并和第i个记录交换。
*/
void select_sort(Sqlist *L)
{
    int i, j;
    int min;
    for(i=0; i<maxsize; i++)
    {
        min = i;
        for(j=i; j<maxsize; j++)
        {
            if(L->r[min] > L->r[j])
                min=j;
        }
        if(i != min)
            swap(L, i, min);
    }
}

/**********************************直接插入排序************************************/
/*
    直接插入排序的基本操作是将一个记录插入到已经排好序的有序表中，
    从而得到一个新的记录数增1的有序表。
*/
void insert_sort(Sqlist *L)
{
    int i, j;
    int temp;

    for(i=1; i<maxsize; i++)
    {
        if(L->r[i] < L->r[i-1])
        {
            temp = L->r[i];
            for(j=i-1; (temp<L->r[j])&&(j>=0); j--)
            {
                L->r[j+1] = L->r[j];
            }
            L->r[j+1] = temp;
        }
    }   
}

/**********************************希尔排序************************************/
/*
    希尔排序的基本思想是，将序列排的基本有序，就是小的关键字
    基本在前面，大的基本在后面，不大不小的在中间。
*/

void shell_sort(Sqlist *L)
{
    int i, j;
    int temp;
    int increment = maxsize;
    do
    {
        increment = increment/3+1;
        for(i=increment; i<maxsize; i++)
        {
            if( L->r[i] < L->r[i-increment] )
            {
                temp = L->r[i];

                for(j=i-increment; (j>=0)&&(temp < L->r[j]); j-=increment)
                    L->r[j+increment] = L->r[j];

                L->r[j+increment] = temp;
            }
        }
    }while(increment>1);
}

/**********************************堆排序***************************************/

/*
    堆排序就是利用堆进行排序的方法，它的基本思想是，将待排序的
    序列构造成一个大顶堆。此时，  整个序列的最大值就是堆顶的
    根结点。将它移走（其实就是将其余堆数组的末尾元素交换，此时
这样就得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。
*/
void Heapsort(Sqlist *L)
{
    int i;

    for(i=maxsize/2; i>=1; i--)
        HeapAdjust(L, i, maxsize);

    for(i=maxsize; i>1 ; i--)
    {
        swap(L, 1, i-1);
        HeapAdjust(L, 1, i-1);
    }
}

void HeapAdjust(Sqlist *L, int m, int n)
{
    int j;
    int temp;

    temp = L->r[m-1];

    for( j=2*m; j<=n; j*=2 )
    {
        if(j<n && L->r[j-1]<L->r[j])
            j--;

        if(temp >= L->r[j-1])
            break;

        L->r[m] = L->r[j];
        m = j;
    }

    L->r[m] = temp;
}

/**********************************归并排序***********************************/
/*
    归并排序就是利用归并的思想实现的排序方法，它的原理就是
    设初始序列包含有n个记录，则可以    看成是n个有序的子序
    列，每个子序列的长度为1，然后两两归并，得到n/2个
    长度为2或1的有序子  序列，并且两两归并。
*/
void Merge_Sort(Sqlist *L)
{
    int i=1;
    M_Sort(L->r, L->r, 0, maxsize-1);
}

void M_Sort(int SR[], int TR1[], int s, int t)
{
    int m;
    int TR2[maxsize];

    if(s == t)
        TR1[s] = SR[s];
    else
    {
        m = (s+t)/2;
        M_Sort(SR, TR2, s, m);
        M_Sort(SR, TR2, m+1, t);
        Merge(TR2, TR1, s, m, t);
    }
}

void Merge(int SR[], int TR[], int i, int m, int n)
{
    int j, k, l;

    for(j=m+1, k=i; i<=m && j<=n; k++)
    {
        if (SR[i]<SR[j])
            TR[k] = SR[i++];
        else
            TR[k] = SR[j++];
    }

    if(i<=m)
    {
        for(l=0; l<=m-i; l++)
        {
            TR[k+l] = SR[i+l];
        }
    }

    if(j<=n)
    {
        for(l=0; l<=n-j; l++)
            TR[k+l] = SR[j+l];
    }
}


/**********************************快速排序**********************************/
/*
    快速排序的基本思想是：通过一趟排序将待排记录
    分割成独立的两个部分，其中一部分记录的关键字
    均比另外一部分的关键字小，则可分别记录继续
    进行排序，以达到整个序列有序的目的。
*/

void Quicksort(Sqlist *L)
{
    QSort(L, 0, maxsize-1);
}

void QSort(Sqlist *L, int low, int high)    //序列分割
{
    int pivot;
    if(low < high)
    {
        pivot = Partion(L, low, high);
        QSort(L, low, pivot-1);
        QSort(L, pivot+1, high);
    }
}

int Partion(Sqlist *L, int low, int high) //
//将关键字两端进行关键字排序
{
    int pivotkey;

    pivotkey = L->r[low];

    while(low < high)
    {
        while(low < high && L->r[high] >= pivotkey)
            high--;
        swap(L, low, high);

        while(low < high && L->r[low] <= pivotkey)
            low++;
        swap(L, low, high);
    }

    return low;
}



/**********************************辅助操作函数*****************************/
/*数据输入函数*/
void data_get(Sqlist *L)
{
    int i;
    printf("*****请输入需要排序的十个数字：*****\n");

    for(i=0; i<maxsize; i++)
        scanf_s("%d",&(L->r[i]));

    printf("\n");
    printf("*****您输入的十个数字依次为：*****\n");

    for(i=0; i<maxsize; i++)
        printf("%d ",L->r[i]);

    printf("\n\n");
}

/*数据打印函数*/
void data_print(Sqlist *L)
{
    int i;

    printf("*****排序后的十个数字为：********\n");

    for(i=0; i<maxsize; i++)
        printf("%d ",L->r[i]);

    printf("\n\n");
}

/**********两个数据交换***********/
void swap(Sqlist *L, int i, int j)
{
    int temp = L->r[i];
    L->r[i] = L->r[j];
    L->r[j] = temp;
}
PTA 6-8 归并排序
wcd278212784的博客
06-08 1774
6-8 归并排序 void Merge(SqList L,int low,int m,int high){ int i,j,now; i=low; j=m+1; now=1; int a[10000];//开个数组保存中间比较过程 while (i<=m&&j<=high){ if(L.elem[i]<=L.elem[j]){ a[now++]=L.elem[i++]; } else{ a[now++]=L.elem[j++]; }
c++常见排序算法总结
qq_71286244的博客
06-30 753
c++常见排序算法总结
归并排序(递归法)
Moliay的博客
09-24 742
本题要求实现二路归并排序中的归并操作，待排序列的长度1<=n<=1000。函数接口定义：其中L是待排序表，使排序后的数据从小到大排列。1000。
PTA 6-1 归并排序(递归法) (10分)
Captain0827的博客
06-03 8583
本题要求实现二路归并排序中的归并操作，待排序列的长度1<=n<=1000。 函数接口定义： void Merge(SqList L,int low,int m,int high); 其中L是待排序表，使排序后的数据从小到大排列。 裁判测试程序样例： #include <iostream> #include <string.h> #include <stdio.h> #include <stdlib.h> #define MAXSIZE 1000
The design and analysis of algorithm：归并排序(递归法)
m0_73426276的博客
10-21 81
归并排序（递归法）
PTA作业笔记
qq_45764891的博客
03-11 2990
window10 JDK的安装
十大经典排序算法总结.docx
08-24
《十大经典排序算法总结》 排序算法是计算机科学的基础，其设计思想和效率对软件的性能有着直接影响。本文主要探讨了十种经典的排序算法，包括它们的设计思路、优缺点以及适用场景，帮助我们理解排序算法的核心。 ...
常见排序算法总结.pdf
03-28
【排序算法总结】 排序算法是计算机科学中处理数据排列的重要工具，主要分为稳定排序和非稳定排序、内排序和外排序两大类。稳定排序保证了相同元素在排序后的相对位置不变，而非稳定排序则不作此保证。内排序是指...
Java实现常见排序算法总结
05-02
【Java实现常见排序算法总结】 排序算法是计算机科学中至关重要的一部分，它涉及到数据处理和算法设计。本文将探讨两种常见的排序算法在Java中的实现：直接插入排序和希尔排序。 1. **直接插入排序（直接插入排序...
(源码)基于C++语言框架的排序算法总结项目.zip
最新发布
08-07
# 基于C++语言框架的排序算法总结项目 ## 项目简介 这是一个基于C++语言的排序算法总结项目，包含了常见的排序算法如冒泡排序、选择排序、插入排序、快速排序、堆排序、归并排序、希尔排序、计数排序、桶排序和...
归并排序和选择排序：Java 和c实现
ch_musk的博客
04-05 591
1.归并排序与选择排序 归并排序定义：归并排序就是将两个或两个以上的有序表合并成一个有序表的过程。将两个有序表合并成一个有序表的过程称为2-路归并。 选择排序定义：每一趟从待排序的记录中选出关键字最小的记录，按顺序放在已排序的记录序列的最后，直到全部排完为止。 注意：1.选择是把一个文件分成包含k个最小元素和n-k个最大元素的两个部分的过程。 2.选择和归并互为逆操作：选择是把一个序列分成...
6-42 归并排序 (10分)
qq_37618760的博客
02-14 7263
本题要求实现二路归并排序中的归并操作，待排序列的长度1<=n<=1000。 函数接口定义： void Merge(SqList L,int low,int m,int high); 其中L是待排序表，使排序后的数据从小到大排列。 类型定义： #include<stdio.h> #include<stdlib.h> typedef int Ke...
6-2 归并排序(递归法)
2303_81795561的博客
09-20 440
其中L是待排序表，使排序后的数据从小到大排列。
八种排序算法和耗时
weixin_67324437的博客
02-16 332
对于大量数据使用八种不同的排序算法去比较所用时间的差别
二路归并排序，C++代码实现
qq1041256623的专栏
10-08 983
#include    using namespace std;   typedef struct    {       int r[100+1];       int length;   }SqList;   //二路归并函数   void Merge(SqList &L,int low,int m,int high)   {//将两个有序区归并为一个有序区       in
每日一题——归并排序
小汤同学
01-29 1202
第一次写博客，大佬们轻点喷 注：作为一个计算机专业的本科生，每日做题也都是必不可少的，这个系列里会更新一些我平时做的一些题目，大都比较简单，不少题目在其他博客里也可以找到，我撰写这些博客仅用于记录。 6-1 归并排序 这是一道比较简单的数据结构的题目，先来看题 题目概况 本题要求实现二路归并排序中的归并操作，待排序列的长度1<=n<=1000。 函数接口定义： void Merge(SqList L,int low,int m,int high); 其中L是待排序表，使排序后的数据从小到大.
6-1 直接插入排序 （10 分）
热门推荐
✨ 欢迎来到【Seal ^_^ 的优快云博客】！✨
12-16 1万+
本题要求实现直接插入排序函数，待排序列的长度1&amp;amp;amp;lt;=n&amp;amp;amp;lt;=1000。 函数接口定义： void InsertSort(SqList L); 其中L是待排序表，使排序后的数据从小到大排列。 类型定义： typedef int KeyType; typedef struct { KeyType *elem; /elem[0]一般作哨兵或缓冲区/ int Length; }SqL...
算法设计与分析
qq_43400374的博客
04-05 2305
算法设计与分析 6-1 归并排序(递归法) (10 分) 本题要求实现二路归并排序中的归并操作，待排序列的长度1<=n<=1000。 函数接口定义： void Merge(SqList L,int low,int m,int high); 其中L是待排序表，使排序后的数据从小到大排列。 裁判测试程序样例： #include <iostream> #include <string.h> #include <stdio.h> #include <stdl
6-4 快速排序
Achievek的博客
04-28 1万+
本题要求实现快速排序的一趟划分函数，待排序列的长度1<=n<=1000。 函数接口定义： int Partition ( SqList L,int low, int high )； 其中L是待排序表，使排序后的数据从小到大排列。 类型定义： typedef int KeyType; typedef struct { KeyType *elem; /elem[0]一般作哨兵或...
数据结构详解：排序算法总结与复杂性分析
本资源是一份关于常用排序算法总结的PPT课件，主要涵盖了数据结构中的排序理论和实践。章节9详细介绍了排序的基本概念，包括排序的定义，即通过特定规则重新排列数据，使其满足非递减关系。排序被划分为稳定和不稳定...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值