头歌-十大经典排序

最新推荐文章于 2024-05-13 22:13:00 发布
最新推荐文章于 2024-05-13 22:13:00 发布
阅读量839 收藏 14
点赞数 13
文章标签： 算法 数据结构 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/toptopniba/article/details/134675021
版权

第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-1; i++){
        for(int j=0;j<n-1-i; 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关：选择排序

//
//  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 *********/
  
    for(int j=0 ; j<n-1; j++){
           int num=j;
      for(int i=j+1 ; i<n; i++){
          if(arr[num]>arr[i])
            num=i;
      }
      swap(arr[j],arr[num]);
      if(j<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 *********/
    for(int j=1 ; j<n; j++){
          int temp=arr[j];
        for(int i=j-1 ; i>=0; i--){
            if(arr[i]>temp)
            {
                arr[i+1]=arr[i];
                arr[i]=temp;
            }else break;
         
         
        }
        if(j<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 i = 0,t=0;
	int k = 0;
	int e = 0;
	int G[4] = {5,2,1,-1};
	int g = G[t];
	while (g > 0)
	{
		for (i = g; i < n; i++)
		{
			k = arr[i];
			e = i - g;
			while (e >= 0 && k<arr[e])
			{
				arr[e + g] = arr[e];
				e-= g;
			}
			arr[e + g] = k;
		}
		print_array(arr, n);
		t++;
		g=G[t];
	}
	print_array(arr, n);


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

第5关：归并排序

#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* arr = (int*)malloc(sizeof(int)*(n1+n2));
    int p = 0;
    int p1 = 0;
    int p2 = 0;
    while (p1<n1 || p2<n2) {
        if(p1<n1 && p2<n2){
            // 自上而下的递归方法使得这两个数组各自是有序的
            // 选择两个数组较小的给arr
            if (arr1[p1]<arr2[p2]) {
                arr[p++] = arr1[p1++];
            }else{
                arr[p++] = arr2[p2++];
            }
        }else if(p1<n1){
            // arr2排完了，余下arr1
            arr[p++] = arr1[p1++];
        }else if(p2<n2){
            // arr1排完了，余下arr2
            arr[p++] = arr2[p2++];
        }
    }
    return arr;
    /********** End **********/
}
int* merge_sort(int *arr, int n)
//  基于merge_array函数编程实现归并排序：自上而下的递归方法
//  函数参数：有序数组arr 数组arr长度
//  函数返回值：返回从小到大排序后的数组
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    if(n==1){
        return arr;
    }
    int m = n/2;
    int* arr1 = (int*)malloc(sizeof(int)*(m));
    int* arr2 = (int*)malloc(sizeof(int)*(n-m));
    for (int i=0, j=0; i<m; i++, j++) {
        // 左半边数组给arr1
        arr1[j] = arr[i];
    }
    for (int i=m, j=0; i<n; i++, j++) {
        // 右半边数组给arr2
        arr2[j] = arr[i];
    }
    // 递归子数组
    arr1 = merge_sort(arr1, m);
    arr2 = merge_sort(arr2, n-m);
    // 合并子数组
    return merge_array(arr1, m, arr2, n-m);
    /********** 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 x = arr[l + r >> 1];
    int i = l - 1,j = r + 1;
 
    while(i < j)
    {
        do ++i;while(arr[i] < x);
        do --j;while(arr[j] > x);
        if(i < j) swap(arr[i],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)
    {
        int k = partition_array(arr,l,r);
        quick_sort(arr,l,k),quick_sort(arr,k + 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 t;
    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)
		{
            t = arr[max];
            arr[max] = arr[j];
            arr[j] = t; 
            adjustHeap(arr,param1,max);		
		}
	}
    /********** End **********/
}
 
int* heap_sort(int *arr, int n)
//  基于adjustHeap函数编程实现堆排序
//  函数参数：无序数组arr 数组长度n
//  函数返回值：返回从小到大排序后的数组
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    int i,t;
    int l=n-1;				
	int p=(l-1)/2;	
	for(int i=p;i>=0;i--)	
	{
		adjustHeap(arr,n,i);	
	}
    for(int i=n-1;i>=0;i--)
	{
        t = arr[i];
        arr[i] = arr[0];
        arr[0] = t;
		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 maxVal = arr[0];
    for (int i=1; i<n; i++) {
        if(maxVal<arr[i]){
            maxVal = arr[i];
        }
    }
    // 申请计数数组，并初始化为0
    int* cnt = (int*)malloc(sizeof(int)*(maxVal+1));
    for (int i=0; i<=maxVal; i++) {
        cnt[i] = 0;
    }
    // 对arr数组元素计数
    for (int i=0; i<n; i++) {
        cnt[arr[i]]++;
    }
    // 顺序输出计数结果
    for (int i=0, k=0; i<=maxVal; i++){
        if (cnt[i]) {
            printf("%d %d\n", i, cnt[i]);
        }
        for (int j=0; j<cnt[i]; j++) {
            arr[k++] = i;
        }
    }
    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 i;
    int maxValue = arr[0];
    for (i = 1; i < n; i++) {
        if (arr[i] > maxValue) {
            maxValue = arr[i];
            // 输入数据的最大值
        }
    }
    // 设置10个桶，依次0，1，，，9
    const int bucketCnt = 10;
    vector<int> buckets[bucketCnt];
    // 桶的大小bucketSize根据数组最大值确定：比如最大值99， 桶大小10
    //                                    最大值999，桶大小100
    // 根据最高位数字映射到相应的桶，映射函数为 arr[i]/bucketSize
    int bucketSize = 1;
    while (maxValue) {
        maxValue /= 10;
        bucketSize *= 10;
    }
    bucketSize /= 10;
    // 入桶
    for (int i=0; i<n; i++) {
        int idx = arr[i]/bucketSize;
        buckets[idx].push_back(arr[i]);
        // 对该桶使用插入排序，维持该桶的有序性
        for (int j=int(buckets[idx].size())-1; j>0; j--) {
            if (buckets[idx][j]<buckets[idx][j-1]) {
                swap(buckets[idx][j], buckets[idx][j-1]);
            }
        }
    }
    // 顺序访问桶，得到有序数组
    for (int i=0, k=0; i<bucketCnt; i++) {
        for (int j=0; j<int(buckets[i].size()); j++) {
            arr[k++] = buckets[i][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* sort_array(int *arr, int n)
//  编程实现《基数排序算法》
//  函数参数：乱序整数数组 数组长度
//  函数返回值：返回从小到大排序后的数组
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
        int i;
    int maxValue = arr[0];
    for (i = 1; i < n; i++) {
        if (arr[i] > maxValue) {
            maxValue = arr[i]; 
            // 输入数据的最大值
        }
    }
    const int radixCnt = 10;
    vector<int> radixs[radixCnt];
    int maxDigit = 0;
    while (maxValue) {
        maxValue /= 10;
        maxDigit++;
    }
    for (int i=0, dev=1; i<maxDigit; i++, dev*=10) {
        for (int j=0; j<radixCnt; j++) {
            radixs[j].clear();
        }   
        for (int j=0; j<n; j++) {
            int digit = (arr[j]/dev)%10;
            radixs[digit].push_back(arr[j]);
        }   
        for (int j=0, t=0; j<radixCnt; j++) {
            for (int k=0; k<int(radixs[j].size()); k++) {
                arr[t++] = radixs[j][k];
            }   
        }   
    }   
    return arr;
    /********** End **********/
}

可以输出hello了
关注
  • 13
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
头歌02-归并排序、快速排序
python一生之敌的博客
05-23 583
已知线性表L1中的数据序列是无序的，请设计归并排序算法和快速排序算法将线性表L1中的数据元素调整为非递减序列或非递增序列。
头歌之算法设计与分析（第一章作业1-必做）：十大经典排序算法.rar
最新发布
07-06
里面的内容分别为： 第1关：冒泡排序 第2关：选择排序 第3关：插入排序 第4关：希尔排序 第5关：归并排序 第6关：快速排序 第7关：堆排序 第8关：计数排序 第9关：桶排序 第10关：基数排序
头歌实验快速排序
Ydsb_w的博客
10-08 839
/ 从基准值之后的第一个元素开始遍历。// 选择第一个元素为基准值。// 从最后一个元素开始遍历。// 从左边找到第一个大于基准值的元素。// 从右边找到第一个小于基准值的元素。// 递归地对基准值两边的子数组进行快速排序。// 交换找到的两个元素。// 将基准值放到正确的位置上。
数据结构与算法-排序算法1-冒泡排序
nameofworld的博客
05-13 1145
排序也称为排序算法。排序是将一组数据依据指定的顺序进行排列的过程。内部排序：将需要处理的所有数据都加载到内存中进行排序。外部排序：数据量过大（比如10亿个数据），无法全部加载到内存中，就需要借助外部存储（文件、磁盘等）进行排序。先加载一部分，排序完之后再加载另外一部分进行排序，排序完再合并。数组中n个元素，从数组第一个元素开始到最后一个元素，依次比较相邻元素的值，如果如果左端元素大于右端元素就交换它们的位置，使得较大的元素在右边。这样数组最右端的元素就是数组中的最大元素。
代码实现 快速排序 数据结构 算法 头歌
weixin_62439745的博客
06-16 4800
快速排序快速排序是建立在冒泡排序基础上的一种排序方法基本思想 :通过一趟排序将要排序的数据分割成独立的两部分其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。实现方法：1.选择一个基准元素，通常选择第一个元素或者最后一个元素。2.比较排序，将小于基准元素的数据移到左边，大于基准元素的数据移到右边。3.再次对左右两边的数据进行排序。4.重复步骤2和3，直到整个数据变成有序序列。通关代码 完整代码...
educoder--实现快速排序
weixin_52563520的博客
12-11 772
任务描述 本关要求通过补全快速排序私有函数QSort__来供函数QuickSort调用，以此来实现快速排序的功能。 相关知识 快速排序的基本过程是：从待排序记录中任选一个记录，以它的排序码作为中心值，将其它记录划分为两个部分，第一部分包含所有排序码小于等于中心值的记录，第二部分包含所有排序码大于中心值的记录。第一部分放在该记录的前面，第二部分放在该记录的后面。对这两个部分采用同样的方法进行处理，直到每个部分为空或只含一个记录为止。 下图 1 给出了一个用中心值将排序记录分割为前后两部分的示例过程。
排序——快速排序
赵士杰——成功并非一蹴而就，而是在持之以恒的努力中逐渐实现。
09-06 255
基本思想 设要排序的数组是 A[0]……A[N−1]A[0]……A[N-1]A[0]……A[N−1]，首先任意选取一个数据（通常选用数组的第一个数）作为轴心，然后将所有比它小的数都放到它左边，所有比它大的数都放到它右边，这个过程称为一趟快速排序。 步骤 选定 PivotPivotPivot 中心轴 将大于 PivotPivotPivot 的数字放在 PivotPivotPivot 的右边 将小于 PivotPivotPivot 的数字放在 PivotPivotPivot 的左边 分别对左右子序列重复前三.
十大排序算法的c++程序实现
05-26
十大排序算法的c++程序实现
财税实务：EXCEL使用十大技巧.pdf
11-28
以下是从提供的文件中提炼出的Excel使用十大技巧的详细解释： 1. 批量添加固定字符： 当需要在单元格内容前批量添加相同字符时，可以插入新列并利用公式。例如，要在证书号前添加"13"，在新列B2中输入公式`="13"&...
EXCEL使用十大技巧【会计实务操作教程】.pptx
11-28
【Excel使用十大技巧详解】 1. 批量添加固定字符： 在Excel中，如果需要在大量数据前批量添加特定字符，例如证书号码前添加"13"，可以通过以下步骤实现： - 首先在原数据右侧插入新列。 - 在新列的第一个单元格...
php 开发十大项目
04-19
3. **论坛系统**：论坛需要处理用户讨论、发帖、回复、搜索等交互，有助于理解会话管理、权限控制以及数据排序和分页。 4. **图片分享平台**：涉及到图片上传、缩略图生成、水印添加等，可以学习PHP处理图像的技巧...
算法设计与分析快速排序算法
06-13
算法的学习，分治
头歌作业之排序1、2、3、4
weixin_62075168的博客
01-01 9172
为了完成本关任务，你需要掌握：链表的相关操作和掌握选择排序算法。为了完成本关任务，你需要掌握：直接插入排序的算法思想。为了完成本关任务，你需要掌握：折半插入排序算法。本关任务：编写一个能实现希尔排序算法的函数。本关任务：编写一个能实现希尔排序算法的函数。本关任务：编写一个能实现希尔排序算法的函数。本关任务：编写一个能实现希尔排序算法的函数。本关任务：编写一个能实现希尔排序算法的函数。本关任务：编写一个能实现希尔排序算法的函数。本关任务：编写函数实现折半插入排序算法。3 9 5 8 7 （数字序列）
排序算法之快速排序
Dejavu的博客
12-12 392
快速排序 快速排序是一种非常优秀的排序算法，应用的也非常广泛，面试时面试官也经常让你手写一个快排，所以说学习快速排序是非常有必要的。 快速排序原理 同归并排序一样，快速排序也是一种分治的排序算法。在归并排序中，通过将数组分成两个子数组进行排序，然后对两个有序的子数组进行归并以将整个数组排序。而快速排序则是选定一个基准值，然后将大于该值的元素放在该元素后面，小于该值的元素放在该值前面。通过不断的递归...
头歌作业之三大排序
LJF330的博客
12-27 499
冒泡排序、选择排序、插入排序
快速排序,选择排序,冒泡排序
weixin_45778852的博客
10-21 311
快速排序 通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 public static int[] qsort(int arr[],int start,int end) { int pivot = arr[start]; ...
头歌数据结构实训参考---十大经典排序算法
m0_73938966的博客
08-22 3429
【代码】头歌数据结构实训参考---十大经典排序算法。
快速排序递归算法详解
stepMore的博客
03-02 2525
快速排序算法的原理和步骤： 首先进行分区，分区指的是从数组随机选取一个值，以其为轴，将比它小的放到它左边，比它大的值放到它右边。 确定指针，我们选取排除轴元素的数组最左（左指针）和最右（右指针）的元素。 具体步骤如下： 左指针逐个格子向右移动，当遇到大于或等于轴的值时，就停下来。 右指针逐个格子向左移动，当遇到小于或等于轴的值时，就停下来。 将两指针所指的值交换位置。 重复上述步骤，直至两指针重合，或左指针移到右指针的右边。 将轴与左指针所指的值交换位置。 快速排序严重依赖于分区。它的运作方式如下所示。
算法设计与分析——十大经典排序算法一（1--5）
weixin_62075168的博客
02-28 4915
算法设计与分析中最经典的十大排序的前五种排序
数据结构-十大经典排序算法
07-27
十大经典排序算法是指在计算机科学中常用的排序算法，它们分别是： 1. 冒泡排序（Bubble Sort）：重复地比较相邻的两个元素，将较大的元素逐渐向右移动。 2. 选择排序（Selection Sort）：每次从未排序的部分选择...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值