代码来咯~

于 2021-12-26 13:12:41 发布
阅读量219 收藏
点赞数 2
分类专栏： C++ 数据结构 文章标签： 排序算法 c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pythpnhh/article/details/122154331
版权

排序

Question one

/*
请设计直接插入排序算法函数void InsertSort(int a[],int n)，对a[1]..a[n]进行升序排序。
并测试在不同数据规模下的排序效率。
*/
#include "Arrayio.h"
#define N 500000     /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/

/*请将本函数补充完整，并进行测试*/
void insertSort(int a[],int n)
{  
	int i, j;
	for(i = 2; i < n; i++)//空出a[0]，并在初始时假设a[1]是有序的
	{//插入排序不需要考虑最后一个数=
		a[0] = a[i];
		j = i - 1;//将a[0]和前面所有的数相比较
		while(a[j] > a[0])
		{
			a[j + 1] = a[j];
			j--;
		}
		a[j + 1] = a[0];
	}
}

int  main()
{
  int a[N+1],n;                     /*数据存储在a[1]...a[N]中*/
  printf("数据初始化...\n");
  n=readData(a,N,"data1.txt");      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
  printf("%d个数据排序中...\n",n);
  insertSort(a,n);
  saveData(a,n,"out.txt");          /*排序结果存放在out.txt文件中*/
  output(a,10);
  printf("排序结束，排序结果保存在out.txt文件中。\n");
  return 0;
}

Question two

/*
请设计二分插入排序算法函数void binInsertSort(int a[],int n)，对a[1]..a[n]进行升序排序。
并测试在不同数据规模下的排序效率。
*/
#include "Arrayio.h"
#define N 10000     /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/

/*请将本函数补充完整，并进行测试*/
void binInsertSort(int a[],int n)
{
    int mid, left, right, i, j;
	for(i = 2; i < n; i++)
	{
		left = 1;//二分查找模板
		right = i - 1;
		while(left <= right)
		{
			mid = (left + right)/2;
			if(a[i] < a[mid])	right = mid - 1;
			else left = mid + 1;
		}
		a[0] = a[i];
		for( j = i - 1; j >= left; j--)	a[j + 1]  = a[j];//后移一个位置
		a[left] = a[0];
	}

}

int  main()
{
  int a[N+1],n;                     /*数据存储在a[1]...a[N]中*/
  printf("数据初始化...\n");
  n=readData(a,N,"data1.txt");      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
  printf("%d个数据排序中...\n",n);
  binInsertSort(a,n);
  saveData(a,n,"out.txt");          /*排序结果存放在out.txt文件中*/
  printf("排序结束，排序结果保存在out.txt文件中。\n");
  return 0;
}

Question three

/*
请设计shell排序算法函数void shellSort(int a[],int n)，对a[1]..a[n]进行升序排序。
并测试在不同数据规模下的排序效率。
*/
#include "Arrayio.h"
#define N 10000     /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/

/*请将本函数补充完整，并进行测试*/
void shellSort(int a[],int n)
{
    int i, j, d;
    d = n/2;//主要是减少了小数在后带来的影响
    while(d >= 1)
    {
		for(i = d + 1; i <= n; i++)//插入排序换皮版；
		{
			a[0] = a[i];
			j = i - d;
			while(j >= 1 && a[j] > a[0])
			{
				a[j + d] = a[j];
				j = j - d;
			}
			a[j + d] = a[0];
		}
	d = d/2;
	}

}

int  main()
{
  int a[N+1],n;                     /*数据存储在a[1]...a[N]中*/
  printf("数据初始化...\n");
  n=readData(a,N,"data1.txt");      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
  printf("%d个数据排序中...\n",n);
  shellSort(a,n);
  saveData(a,n,"out.txt");          /*排序结果存放在out.txt文件中*/
  printf("排序结束，排序结果保存在out.txt文件中。\n");
  return 0;
}

Question four

/*
请设计简单选择排序算法函数void selectSort(int a[],int n)，对a[1]..a[n]进行升序排序。
并测试在不同数据规模下的排序效率。
*/
#include "Arrayio.h"
#define N 10000     /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/

/*请将本函数补充完整，并进行测试*/
void selectSort(int a[],int n)
{
    int i, j, min;
    for(i = 1;i < n; i++)
    {
		min = i;//找到那个最下的数
		for(j = i + 1;  j <= n; j++)
			if(a[min] > a[j])
				min = j;
		if(min != i)//如果不相等就交换两者的值
		{
			a[0] = a[i];
			a[i] = a[min];
			a[min] = a[0];
		}	
	}
}

int  main()
{
  int a[N+1],n;                     /*数据存储在a[1]...a[N]中*/
  printf("数据初始化...\n");
  n=readData(a,N,"data1.txt");      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
  printf("%d个数据排序中...\n",n);
  selectSort(a,n);
  saveData(a,n,"out.txt");          /*排序结果存放在out.txt文件中*/
  printf("排序结束，排序结果保存在out.txt文件中。\n");
  return 0;
}

Question five

/*
请设计筛选函数void sift(int a[],int k,int n)，对a[k] 进行筛选，
并利用其设计堆排序算法函数void heapSort(int a[],int n)，
对a[1]..a[n]进行升序排序。并测试在不同数据规模下的排序效率。（详见lab10_05.c）
*/
#include "Arrayio.h"
#define N 10000     /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/

/*请将本函数补充完整，并进行测试*/
void sift(int a[],int k,int n)
{
      int i,j,finished;
      i=k;j=2*i;
      a[0]=a[k];
      finished=0;
      while((j<=n)&&(!finished))
      {
        if((j<n)&&(a[j+1]>a[j]))
             j++;
        if(a[0]>=a[j])
             finished=1;
        else
        {
          a[i]=a[j];
          i=j;j=2*j;
        }
      }
      a[i]=a[0];
    }

void heapSort(int a[],int n)
{
    int i;
    for (i=n/2;i>=1;i--)
        sift(a,i,n);
    for (i=n;i>1;i--)
        {
            a[0]=a[i];
            a[i]=a[1];
            a[1]=a[0];
            sift(a,1,i-1);
        }
}

int  main()
{
  int a[N+1],n;                     /*数据存储在a[1]...a[N]中*/
  printf("数据初始化...\n");
  n=readData(a,N,"data1.txt");      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
  printf("%d个数据排序中...\n",n);
  heapSort(a,n);
  saveData(a,n,"out.txt");          /*排序结果存放在out.txt文件中*/
  printf("排序结束，排序结果保存在out.txt文件中。\n");
  return 0;
}

Question six

/*
请设计冒泡排序算法函数void bubbleSort(int a[],int n)，对a[1]..a[n]进行升序排序。
并测试在不同数据规模下的排序效率。
*/
#include "Arrayio.h"
#define N 10000     /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/

/*请将本函数补充完整，并进行测试*/
void bubbleSort(int a[],int n)
{
    int i, flag = 1;//flag用来判断结果是否是已经排好序的
    while(flag == 1 && n > 1)
    {
    	flag = 0;
		for(i = 1; i < n; i++)
		{
			if(a[i] > a[i + 1])//交换
			{
				a[0] = a[i];
				a[i] = a[i + 1];
				a[i + 1] = a[0];
				flag = 1;
			}
		}
		n--;
	}
}

int  main()
{
  int a[N+1],n;                     /*数据存储在a[1]...a[N]中*/
  printf("数据初始化...\n");
  n=readData(a,N,"data1.txt");      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
  printf("%d个数据排序中...\n",n);
  bubbleSort(a,n);
  saveData(a,n,"out.txt");          /*排序结果存放在out.txt文件中*/
  printf("排序结束，排序结果保存在out.txt文件中。\n");
  return 0;
}

Question seven

/*
请设计快速排序算法函数void quickSort(int a[],int low,int right)，对a[low]..a[right]进行升序排序。
并测试在不同数据规模下的排序效率。
*/
#include "Arrayio.h"
#define N 10000     /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/


void exchange(int *a, int *b)
{
	int num;
	num = *a;
	*a = *b;
	*b = num;
}

/*请将本函数补充完整，并进行测试*/
void quick_sort(int a[], int low, int high)
{
    if( low >= high) return;
    int i = low - 1, j = high + 1, x = a[(low + high)/2];//初始化边界，最优的节点值为中间
    while(i < j)//如果满足二分的条件就可以继续二分
    {
        do i++;while( a[i] < x);
        do j--;while( a[j] > x);
        if(i < j) exchange(&a[i], &a[j]);//找到两个满足条件的结果并交换
    }
    quick_sort(a, low, j);
    quick_sort(a, j+1, high);
}


int  main()
{
  int a[N+1],n;                     /*数据存储在a[1]...a[N]中*/
  printf("数据初始化...\n");
  n=readData(a,N,"data1.txt");      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
  printf("%d个数据排序中...\n",n);
  quick_sort(a,1,n);
  saveData(a,n,"out.txt");          /*排序结果存放在out.txt文件中*/
  printf("排序结束，排序结果保存在out.txt文件中。\n");
  return 0;
}

Question eight

/*
请设计归并排序算法函数void mergeSort(int a[],int n)，对a[1]..a[n]进行升序排序。
并测试在不同数据规模下的排序效率。
*/
#include "Arrayio.h"
#define N 10000     /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/

/*请将本函数补充完整，并进行测试*/

void merge(int a[],int u,int m,int v)
{ /*将有序段a[u..m],a[m+1..v]归并到a[u..v]*/

    int i,j,k,t;
    int b[N+1];
    i=u; j=m+1; k=u;
    while (i<=m && j<=v)
    {
		if(a[i]<=b[j] )
        {
			b[k]=a[i];
            i++;
       }
       else
       {
	   		b[k]=a[j];
        	j++;
       }
       k++;
    }
  if (i>m)
      for (t=j;t<=v;t++)
                b[k+t-j]=a[t];
  else
      for (t=i;t<=m;t++)
                b[k+t-i]=a[t];
  /*将l2表中的内容拷贝回表l1*/
  for (i=u;i<=v;i++)
                a[i]=b[i];
}
/*----一趟归并------*/
 int  mergepass(int a[],int n,int len)
  { /*对a[1..n]进行长度为len的一趟并归*/
    int i,t;
    i=1;
    while (i<=n-2*len+1)
      {         merge(a,i,i+len-1,i+2*len-1);
                i=i+2*len;
      }

    if (i+len-1<n)
            merge(a,i,i+len-1,n);
 }

/*----归并排序------*/
void mergeSort(int a[],int n)
{   int  len, b[N+1];
    len=1;
    while (len<n)
      {     mergepass(a,n,len);//从一开始不断扩大合并
             len=len*2;
      }
}
/*归并排序的递归实现*/
void mergeSortdc(int a[],int low,int high)
{
    int mid;
    if (low<high)
    {
        mid=(low+high)/2;
        mergeSortdc(a,low,mid);//不断的划分成不能再划分
        mergeSortdc(a,mid+1,high);
        merge(a,low,mid,high);
    }
}

int  main()
{
  int a[N+1],n;                     /*数据存储在a[1]...a[N]中*/
  printf("数据初始化...\n");
  n=readData(a,N,"data1.txt");      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
  printf("%d个数据排序中...\n",n);
  mergeSort(a,n);                   /* 或调用mergeSortdc(a,1,n); */
  saveData(a,n,"out.txt");          /*排序结果存放在out.txt文件中*/
  printf("排序结束，排序结果保存在out.txt文件中。\n");
  return 0;
}

Question nine

/*
请设计基于链表的基数排序函数void radixSort(linklist head)，对带头结点的整型非负单链表进行升序排序。
并测试在不同数据规模下的排序效率。(注：链表中的最大整数为500000)
*/
#include "slnklist.h"
struct  node2
{
    linklist front,rear;
};
#define N 1000     /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/

/*请将本函数补充完整，并进行测试*/

void radixSort(linklist head)
{
    struct node2 q[10];/*队列*/
    linklist  p,r;
    int i,j,k,x;
    for (j=0;j<10;j++)
            q[j].rear=q[j].front=NULL;
    for (i=0;i<6;i++)  //排序的最大数为6位数，共进行6趟分配收集过程
    {
        p=head->next;       //分配
        while (p)
            {
                    head->next=p->next;
                    x=p->info;
                    for (j=0;j<i;j++)
                            x=x/10;
                    k=x%10;                                     //取出本次按位分配的值
                    if (q[k].front==NULL)           //队列为空
                    {
                        q[k].front=q[k].rear=p;
                    }
                    else                                            //队列不为空
                    {
                         q[k].rear->next=p;
                         q[k].rear=p;
                    }
                   p=head->next;
            }
        //收集
        r=head;                             //r为链尾指针
        for (j=0;j<10;j++)
        {
            if (q[j].front!=NULL)
                        {   r->next=q[j].front;
                             r=q[j].rear;
                             q[j].front=q[j].rear=NULL;
                        }
        }
        r->next=NULL;
    }
}

int  main()
{
  linklist head;
  printf("数据初始化...\n");
  head=creatLink("data1.txt",N);      /*从data1.txt中读入N个整数存入数组a，n为实际读入的数据个数*/
  printf("数据排序中...\n");
  radixSort(head);
  writetofile(head,"out.txt");        /*排序结果保存在out.txt中*/
  delList(head);
  return 0;
}
菜狗原来是我自己
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
李云清版数据结构答案
03-29
以前看严的数据结构，觉得没有这本书好，没这本书适合咱们初学者
数据结构C语言版（李云清）实验1 线性表的顺序实现
CSDNadmin00的博客
12-28 4890
实验一 线性表的顺序实现 1、 基于sequlist.h中定义的顺序表，编写算法函数reverse(sequence_list *L)，实现顺序表的就地倒置。 /**********************************/ /*文件名称：lab1-01.c */ /**********************************/ #include "sequ...
插入排序
m0_49371394的博客
01-17 1467
题目描述： 设计函数 void InsertSort(int a[],int n); 该函数使用插入排序算法，将数组a的前n个元素按照升序的方式排序。 插入排序算法描述如下： 初始序列：49 38 65 97 76 13 27 49 将元素(38) 插入合适位置： [38 49] 65 97 76 13 27 49 将元素(65) 插入合适位置： [38 49 65] 97 76 13 27 49 将元素(97) 插入合适位置： [38 49 65 97] 76 13 27 49 将元素(76) 插入合适位
数据结构C语言版（李云清）实验10 排序
CSDNadmin00的博客
12-28 3930
实验10 排序 1、请设计直接插入排序算法函数void insertSort(int a[],int n)，对a[1]…a[n]进行升序排序。并测试在不同数据规模下的排序效率。 #include "Arrayio.h" #define N 500000 /*N为数据量大小，因data1.txt中只有50万个数，所以自行设定N值时需让N<=500000*/ /*请将本函数补充完整，...
排序
weixin_43931042的博客
12-07 539
题目描述 void InsertSort(int a[],int n); 使用插入排序算法，将数组a的前n个元素按照升序的方式排序。 插入排序算法描述如下： 初始序列：49 38 65 97 76 13 27 49 将元素(38) 插入合适位置： [38 49] 65 97 76 13 27 49 将元素(65) 插入合适位置： [38 49 65] 97 76 13 27 49 将元素(97)...
排序——数据结构课程作业
weixin_33716154的博客
12-22 339
(╥╯^╰╥) 1 /* 2 请设计直接插入排序算法函数void insertSort(int a[],int n)，对a[1]..a[n]进行升序排序。 3 并测试在不同数据规模下的排序效率。 4 */ 5 #include "Arrayio.h" 6 #define N 10000 /*N为数据量大小，因data1.txt中只有50万个数，所以自...
排序算法及其部分知识点
weixin_42456671的博客
09-30 154
排序 插入排序（InsertSort） 将一个待排序的记录按其关键字大小插入到前面已排好的子序列中 代码实现 void InsertSort(int A[], int n){ int i, j, temp; for(i=1; i<n; i++){ // 将各元素插入到已排好序的子序列中 if(A[i] < A[i-1]){ // 若A[i]关键字小于其前驱 temp = A[i]; // tem
贪吃蛇python代码来了！！！
最新发布
06-30
【贪吃蛇】python代码来了！下载就能用！（有问题的找我）
cleancode代码整洁
02-25
比如我，从一个天天被骂代码写得烂的人，逐渐学习成长，到现在也能写的出“人模人样”的代码来了。这期间算是积累了一点经验心得，想和大家分享，抛砖引玉。本文主要针对面向对象编程的cleancode来阐述，面向过程...
新闻来了 源码
03-17
【标题】"新闻来了 源码"是一个与新闻应用相关的源代码项目，可能是为了帮助开发者学习和理解如何构建一个新闻资讯类的应用程序。在这一领域，开发者通常会涉及到多种编程语言、框架和库，例如Java、Python、React ...
Android代码-Glide v4最全中文文档来了！
08-06
Glide 文档中文翻译项目 这个项目专注于为 Glide 4.x 版本文档提供简体中文翻译。 其他语言版本 目前，你可以使用以下语言阅读 Glide v4 的文档： English 简体中文 한국어 关于文档的一致性 ...
字符数组、排序、查找
vnalk的博客
11-29 447
1.简单排序 设计函数 void bubbleSort(int a[],int n);，实现对整型数组的排序。 输入第一行为一个整数n(0<n<=1000),代表待排序元素的个数。第二行是n个整数，每个整数都不会超过int型的存储范围，为待排序元素。 输出只有一行，为输入的n个待排序元素按从小到大排序后的结果。（建议采用起泡排序算法） 建议设计一个辅助函数: 函数功能：依次输出数组中各个元素，数与数之间用空格分开，最后一个数后没有空格而是换行符 参数说明：数组名，数组内元素个数 void out
排序算法1_直接插入排序
mobai
06-06 387
概述：     排序分为两大类，内部排序和外部排序，内部排序指的是待排序记录存放在计算机随机存储器中进行排序过程，外部排序指的是待排序记录数量很大，以致内存不能一次容纳全部记录，在排序过程中尚需对外存进行访问的排序过程，这里我主要给出内部排序：   其中稳定排序：插入排序、冒泡排序、归并排序、基数排序。 直接插入排序：基本操作是将一个记
数据结构C语言版（李云清）实验6 树
CSDNadmin00的博客
12-28 4627
实验6 树 1、编写算法函数void levelorder(tree t)实现树的层次遍历。 #include "tree.h" void levelorder(tree t) /* t为指向树根结点的指针*/ { tree queue[MAXLEN]; /*用队列存放待处理的结点*/ int head=0,end=1; int i; queue[head] = t;...
算法基础-直接插入排序
记录计算机应用的点点滴滴！！！！！
02-27 739
一、直接插入排序 直接插入排序，下面使用了3中方法实现了。 二、算法实现 // 直接插入排序.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include using namespace std; void InsertSort1(int a[],int n); void InsertSort2(int a[],int n); void
排序算法3——直接插入排序
shuzfan的专栏
02-07 862
直接插入排序的平均复杂度是 \(O(n^2)\)，因此应用场景较少。直接插入排序的思路是： 每次处理一个数据，将其插入到一个已经排好序的子序列中，直到数据处理完毕。下面给出一个动画示例：未完待续。。。。参考资料：（1）WIKI：https://en.wikipedia.org/wiki/Insertion_sort
直接插入排序
河马的BLOG
03-30 644
直接插入排序的算法的思想 就是将一个待排序的值插入到一个有序序列中去，插入的时候是从后向前插入最差时间复杂度：O(n^2) 最优时间复杂度：O(n) 平均时间复杂度：O(n^2) 稳定性：稳定实例： //从小到大排序 void insertSort1(int *a,int n){ for(int i=1; i<n; i++){ //如果前一个数大于后一个数则进行排序，否
经典算法学习——直接插入排序
乞力马扎罗的雪CYF的博客
02-03 2282
直接插入排序也是比较简单的排序，基本思想是：每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子序列中的适当位置，直到全部记录插入完成为止。具体描述如下：设数组为a[0...n-1],（1）初始时，a[0]自成为一个有序区，无序区为a[1...n-1]. 令i=1;（2）将a[i]并入到当前的有序区a[0...i-1]中形成a[0...i]的有序区间；（3）i++并重复（2），直到i==
sonarqube代码扫描
05-13
SonarQube是一款开源的代码质量管理平台，可以用来进行代码扫描和静态代码分析。它可以帮助开发人员自动化地检测代码质量问题，并提供有关如何解决这些问题的建议。 使用SonarQube进行代码扫描主要分为以下几个步骤： 1. 安装SonarQube服务器：可以从SonarQube官方网站上下载并安装SonarQube服务器，也可以使用Docker等容器技术进行部署。 2. 集成构建工具和代码扫描插件：SonarQube支持各种构建工具和编程语言，例如Maven、Gradle、Ant、Jenkins等。需要在项目中集成相应的插件，并在构建过程中执行SonarQube扫描命令。 3. 运行代码扫描：在项目构建过程中执行SonarQube扫描命令，将扫描结果上传到SonarQube服务器。 4. 查看扫描结果：在SonarQube服务器上查看代码扫描结果，包括代码质量分数、代码缺陷、安全漏洞等，以及相应的修复建议。 通过使用SonarQube进行代码扫描，可以帮助开发人员及时发现和修复代码质量问题，提高代码质量和可维护性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

菜狗原来是我自己

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

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

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

打赏作者

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

抵扣说明：

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

余额充值