头歌数据结构实训参考---十大经典排序算法

已于 2023-08-22 20:37:22 修改
阅读量2.3k 收藏 47
点赞数 8
文章标签： 数据结构 排序算法 算法
于 2023-08-22 20:36:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73938966/article/details/132436235
版权

可通过 目录 快速查阅对应排序算法

第1关 冒泡排序


#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 *********/
    for(int i=0;i<n;i++)
    {
    for(int j=0;j<n-1;j++)
    {
     if(arr[j]>arr[j+1])
     {
         int temp=arr[j];
         arr[j]=arr[j+1];
         arr[j+1]=temp;
     }
    }
    if(i<3)
    print_array(arr,n);
    }
    print_array(arr,n);

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

第2关 选择排序


#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 index,min;
    for(int i=0;i<n-1;i++)
    {
        min=arr[i];
        index=i;
    for(int j=i+1;j<n;j++)
    {
        if(min>arr[j])
        {
            min=arr[j];
            index=j;
        }
    }
    arr[index]=arr[i];
    arr[i]=min;
    if(i<3)
    print_array(arr,n);
    }
    print_array(arr,n);

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

第3关 插入排序



#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 temp,index;
    for(int i=1;i<n;i++)
    {
        temp=arr[i];
        index=i;
        for(int j=i-1;j>=0;j--)
        {
            if(arr[j]>temp)
			{
				arr[index--]=arr[j];
				arr[j]=temp;
			}
        }
    if(i<4)
    print_array(arr,n);
    }
    print_array(arr,n);
    
	
    
    /********** End **********/
}

第4关 希尔排序


#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 sort_array[]={5,2,1};
    int temp,index,sep;
    for(int k=0;k<3;k++)
    {
        sep=sort_array[k];
    for(int i=sep;i<n;i++)
    {
        temp=arr[i];
        index=i;
        for(int j=i-sep;j>=0;j-=sep)
        {
            if(arr[j]>temp)
			{
				arr[index]=arr[j];
                index-=sep;
				arr[j]=temp;
			}
        }
    }
    print_array(arr,n);
    }
    print_array(arr,n);
    
    /********** End **********/
}

第5关 归并排序


#include "sort_.h"
int cmp(const void*a,const void*b)
{
    return (*(int*)a-*(int*)b);
}
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;
    arr3=(int*)malloc(sizeof(int)*(n1+n2));
    int a1=0,a2=0,a3=0;
    while(a1<n1&&a2<n2)
    {
        if(arr1[a1]<=arr2[a2])
        arr3[a3++]=arr1[a1++];
        else
        arr3[a3++]=arr2[a2++];
    }
    while(a1<n1)
    arr3[a3++]=arr1[a1++];
    while(a2<n2)
    arr3[a3++]=arr2[a2++];
    return arr3;
    /********** End **********/
}
int* merge_sort(int *arr, int n)
//  基于merge_array函数编程实现归并排序：自上而下的递归方法
//  函数参数：有序数组arr 数组arr长度
//  函数返回值：返回从小到大排序后的数组
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int *rarr=&arr[n/2];
    int lr=n-n/2;
    qsort(arr,n/2,sizeof(int),cmp);
    qsort(rarr,lr,sizeof(int),cmp);
    merge_array(arr,n/2, rarr, lr);
    /********** End **********/
}

第6关 快速排序


#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 temp = arr[l];
	while(l<r)
	{        
		while((l<r)&&arr[r]>=temp)
			r--;
		arr[l] = arr[r];
		while((l<r)&&arr[l]<=temp)
			l++;
		arr[r] = arr[l];

    }
    arr[l] = temp;
    return l;
    /********** End **********/
}

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

    if(l<r)
    {
        if(l<pos-1)
			arr = quick_sort(arr,l,pos-1);
        if(pos+1<r)
            arr = quick_sort(arr,pos+1,r);
    }
    return arr;

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

第7关 堆排序


#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=0;
    if(j<param1)
	{
		int max=j;
		int s1=2*j+1;
		int s2=2*j+2;
		if(arr[s1]>arr[max]&&s1<param1)
			max=s1;
		if(arr[s2]>arr[max]&&s2<param1)
			max=s2;
		
		if(max!=j)
		{
			
            temp = arr[max];
            arr[max] = arr[j];
            arr[j]   = temp; 
			
            adjustHeap(arr,param1,max);		
		}
	}
    /********** End **********/
}

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

        temp = arr[i];
        arr[i] = arr[0];
        arr[0] = temp;	
		adjustHeap(arr,i,0);		
	}
    return arr;

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

 第8关 计数排序



#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=arr[0];
    int min=arr[0];
    for(int i=0;i<n;i++)
    {
        if(arr[i]>max)
        max=arr[i];
        if(arr[i]<min)
        min=arr[i];
    }
    int num[1000]={0};
    for(int i=0;i<n;i++)
    num[arr[i]]++;
    int index=-1;
    for(int j=min;j<=max;j++)
    {
        if(num[j]!=0)
        printf("%d %d\n",j,num[j]);
        int temp = num[j];
        while(num[j]!=0) 
        {
            arr[++index] = j;
            num[j]--;
        }
    }
    print_array(arr,n);

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

第9关 桶排序



#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 max=arr[0];
    int min=arr[0];
    for(int i=0;i<n;i++)
    {
        if(arr[i]>max)
        max=arr[i];
        if(arr[i]<min)
        min=arr[i];
    }
    int num[100]={0};
    for(int i=0;i<n;i++)
    num[arr[i]]++;
    int index=-1;
    for(int j=min;j<=max;j++)
    {
        if(num[j]!=0)
        int temp = num[j];
        while(num[j]!=0) 
        {
            arr[++index] = j;
            num[j]--;
        }
    }
    return arr;
    /********** End **********/
}

第10关 基数排序



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

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

HUTAC
关注
  • 8
    点赞
  • 踩
  • 47
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
十大经典排序算法源码.cpp
05-02
爆肝整理！堪称全网最详细的十大常用经典排序算法总结！！！ C++模板类实现，附带部分测试用例！！！
头歌作业之三大排序
最新发布
LJF330的博客
12-27 437
冒泡排序、选择排序、插入排序
十大经典排序算法
思域传媒的博客
02-08 330
一、直接插入排序 二、希尔排序 三、冒泡排序 四、快速排序 五、简单选择排序 六、堆排序 七、归并排序 八、基数排序 九、计数排序 十、桶排序 一、直接插入排序 【算法思想】 【代码】 public void insertSort(int[] nums){ int len = nums.length; //len=10 for(int i=1;i<len;i++){...
数据结构C语言实验代码
01-01
一个学期编写练习的一些代码，包含各种排序算法，图的遍历Prim算法，Huffman编码，Hash字符匹配，约瑟夫环问题，有一个自己编写的栈和队列，存入了一个静态库中，队列通过单循环链表实现，栈则是普通的数组，部分代码通过类来实现。所有代码放入了一个解决方案中，VS2019可以直接运行。
算法设计与分析快速排序算法
06-13
算法的学习，分治
C语言实现基数排序
helpluozhao123的博客
01-15 538
#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) // 函数参
头歌作业之排序1、2、3、4
weixin_62075168的博客
01-01 8348
为了完成本关任务，你需要掌握：链表的相关操作和掌握选择排序算法。为了完成本关任务，你需要掌握：直接插入排序的算法思想。为了完成本关任务，你需要掌握：折半插入排序算法。本关任务：编写一个能实现希尔排序算法的函数。本关任务：编写一个能实现希尔排序算法的函数。本关任务：编写一个能实现希尔排序算法的函数。本关任务：编写一个能实现希尔排序算法的函数。本关任务：编写一个能实现希尔排序算法的函数。本关任务：编写一个能实现希尔排序算法的函数。本关任务：编写函数实现折半插入排序算法。3 9 5 8 7 （数字序列）
C语言实现选择排序
helpluozhao123的博客
01-15 610
#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) // 编程实
C语言 实现 归并排序 算法 头歌 数据结构
weixin_62439745的博客
06-15 2404
归并排序 将数组arr分成两个子数组，然后对两个子数组进行归并排序，最后将两个子数组归并成一个有序数组函数参数：整数数组arr 数组长度要求输出：调用print_array(int *arr, int n)输出前三次选择操作后的序列，以及最终的升序序列函数实现：1. 分组：将数组分成两个子数组，分别为arr[0..n/2]和arr[n/2+1..n]2. 归并：将两个子数组进行归并排序，最后将两个子数组归并成一个有序数组3. 循环直到数组长度为1，即完成排序4.返回...
Java数据结构和算法中文第二版
12-24
《数据结构(第2版)》介绍了各种常用的数据结构及其操作，包括线性表、栈和队列、串、数组、树、图、查找和排序等。全书使用标准的C语言作为算法描述工具。《数据结构(第2版)》内容通俗易懂，侧重于应用，力求内容与应用实例相结合，并附有上机实验和实训指导，有利于提高读者分析问题和解决问题的能力。 《数据结构(第2版)》可以作为高职高专院校计算机相关专业的教材，也可以作为专升本、自学考试的辅导教材。
数据结构排序试验 C语言完整版
08-24
文档完整的实现了数据结构中排序的所有算法，并给出了时间的统计，用于比较排序算法在对待不同的数据时消耗的时间，从而帮助理解算法。文档中有个头定义的变量，可以设定共产生多少数.
数据结构设计报告实验三
12-04
掌握各种排序方法的算法实现思想和存储表示方法； 掌握所选排序方法的C语言编程技巧； 按照实验题目要求独立正确地完成实验内容（提交程序 及相关实验数据与完整运行结果）； 认真书写实验报告,并按时提交。
数据结构(C语言版)
04-15
除第1章外，其余每章最后一节以实训的形式给出了本章重点算法的应用实例，以便于上机验证。 本书基本理论的阐述由浅入深、算法描述清晰、内容安排合理、语言精练、逻辑推理严密，适合作为高职高专院校计算机类或信息...
数据结构案例教程(C语言版).rar
10-18
《数据结构案例教程(C语言版)》共分为8章，内容包括线性表，栈和队列，串、数组和广义表，树和二叉树，图，查找，排序和综合实训。《数据结构案例教程(C语言版)》可作为高职高专院校计算机类专业或信息类专业的教材...
2 归并排序
weixin_44677653的博客
07-31 228
归并排序
【排序算法】十大排序之计数排序
北方的孤夜
04-29 90
计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，。计数排序 (Counting sort) 是一种稳定的排序算法。计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。计数排序是一个非基于比较的，该算法于1954年由 Harold H. Seward 提出。它的优势在于在对一定范围内的整数排序时，它的为Ο(n+k)（其中k是整数的范围），快于任何比较排序算法。
十大经典的排序算法
qq_46796338的博客
06-03 247
排序算法是《数据结构与算法》中最基本的算法之一，下面价绍了七种排序方式，分别是插入排序、希尔排序、选择排序、冒泡排序、归并排序等，附加源代码 1.冒泡排序 算法步骤： 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。 针对所有的元素重复以上的步骤，除了最后一个。 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较 C源代码： #include<stdio.h> //按升序排序
数据结构各类排序算法详解+代码分析
LRY89757的博客
06-30 1588
数据结构各类排序算法详解+代码分析 前言 不知不觉，数据结构已经学完了，博主也马上大二了????时间过得太快了????，但是数据结构学得确实不太好，楼主花了将近一天的时间整理了一下排序的有关算法。希望对大家也有所帮助。 目录数据结构各类排序算法详解+代码分析前言插入排序基本思想直接插入排序折半插入排序二路排序希尔排序快速排序选择排序基本思想简单选择排序锦标赛排序堆排序堆定义建堆堆排序算法代码解析归并排序基数排序总结排序方法比较方法选择写在后面 插入排序 基本思想 每步将一个待排序记录，按其关键码大小，插
数据结构与算法 - 排序
09-14
排序是计算机科学中常见的操作，它将一组元素按照特定的顺序重新排列。排序算法的目标通常是将元素按照升序或降序排列。 常见的排序算法有很多种，每种算法都有不同的时间复杂度和空间复杂度。以下是几种常见的排序算法： 1. 冒泡排序（Bubble Sort）：比较相邻的两个元素，如果顺序不正确就交换位置，每次遍历将一个最大（最小）的元素移到最后（最前）。时间复杂度为O(n^2)。 2. 插入排序（Insertion Sort）：将数组分为已排序和未排序两部分，每次从未排序部分取出一个元素，插入已排序部分的适当位置。时间复杂度为O(n^2)。 3. 选择排序（Selection Sort）：每次从未排序部分选择一个最小（最大）的元素放到已排序部分的末尾。时间复杂度为O(n^2)。 4. 快速排序（Quick Sort）：选取一个基准元素，将数组划分为两个子数组，小于基准元素的放在左边，大于基准元素的放在右边，然后对子数组进行递归排序。时间复杂度平均情况下为O(nlogn)，最坏情况下为O(n^2)。 5. 归并排序（Merge Sort）：将数组递归分成两个子数组，然后对子数组进行排序，最后将两个已排序的子数组合并成一个有序数组。时间复杂度为O(nlogn)。 6. 堆排序（Heap Sort）：将数组构建成一个最大（最小）堆，每次从堆顶取出最大（最小）元素放到已排序部分的末尾，然后调整堆使其满足堆的性质。时间复杂度为O(nlogn)。 这里只介绍了几种常见的排序算法，每种算法都有其适用的场景和优缺点。在实际应用中，根据数据规模和性能要求选择合适的排序算法非常重要。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

HUTAC

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值