数据结构--实验5---排序(c)

仅供参考

  1 #include  "stdio.h"
  2 #include  "stdlib.h"
  3 #include  "iomanip.h"
  4 #include  "time.h"
  5 #include "iostream.h"
  6 const   int  N=150000;
  7 #define  ElemType  int
  8 void insertsort(ElemType R[],int n)      //直接插入排序
  9 {  for ( int i=1; i<n; i++)        //i表示插入次数,共进行n-1次插入
 10    { ElemType temp=R[i];        //把待排序元素赋给temp
 11     int j=i-1;
 12     while ((j>=0)&& (temp<R[j]))
 13  {      R[j+1]=R[j]; j--; }              // 顺序比较和移动
 14         R[j+1]=temp;}
 15 }
 16
 17 void BinaryInsertSort(ElemType R[],int n)    //二分插入排序
 18 {   for(int i=1; i<n; i++)                      //共进行n-1次插入
 19   { int left=0,right=i-1;ElemType temp=R[i];
 20     while(left<=right)
 21     {  int middle=(left+right)/2;             //取中点
 22        if(temp<R[middle]) right=middle-1;    //取左区间
 23        else   left=middle+1; }               //取右区间
 24      for(int j=i-1;j>=left;j--)
 25 R[j+1]=R[j];    //元素后移空出插入位
 26       R[left]=temp;  }
 27 }
 28
 29 void Bubblesort(ElemType R[],int n)          //冒泡排序
 30 {  int flag=1;  //当flag为0则停止排序
 31   for  (int i=1; i<n; i++)                //i表示趟数,最多n-1趟
 32   {
 33     flag=0;                               //开始时元素未交换
 34     for (int j=n-1; j>=i; j--)
 35       if (R[j]<R[j-1])                      //发生逆序
 36        {  ElemType t=R[j];
 37       R[j]=R[j-1];
 38       R[j-1]=t;flag=1; }                    //交换,并标记发生了交换
 39           if (flag==0)  return;      }
 40 }
 41
 42 void   selectsort(ElemType R[],int n)      //直接选择排序
 43 {  int  i,j,m;
 44    ElemType t;
 45    for ( i=0;i<n-1; i++ )
 46    {   m=i ;
 47        for ( j=i+1;j<n;j++ )
 48          if  ( R[j]<R[m] )  m=j  ;
 49        if ( m!=i )  { t=R[i] ; R[i]=R[m] ; R[m]=t ;  }
 50     }
 51 }
 52 int quick_once(ElemType R[],int low,int high){
 53         ElemType t=R[low];
 54         while(R[high]>=t&&high>low){
 55             high--;
 56             R[low]=R[high];
 57
 58
 59         while(R[low]<=t&&low<high)
 60             low++;
 61             R[high]=R[low];
 62         }
 63         R[high]=t;
 64         return high;
 65
 66
 67 }
 68 void quicksort(ElemType R[],int low,int high)
 69 {
 70     int mid;
 71     if(low>=high)
 72         return;
 73     mid=quick_once(R,low,high);
 74     quicksort(R,low,mid-1);
 75     quicksort(R,mid+1,high);
 76     return;
 77
 78 }
 79 void Shellsort(ElemType R[],int n)
 80 {
 81     int i,j;
 82     ElemType t;
 83     for(int d=n/2;d>1;d/=2)
 84     for(int j=d;j<n;j++)
 85         t=R[j];
 86         while(i>0&&i-d>0&&R[i]<R[i-d]){
 87             R[i]=R[i-d];
 88         R[i]=t;
 89     }
 90
 91
 92 }
 93 void print(ElemType R[],int n)            //打印数组
 94 {
 95    for(int i=0;i<n;i++)
 96    {  if (i%10==0)  printf("\n");
 97       printf("%7d",R[i]);
 98    }
 99    printf("\n");
100 }
101 void main()
102 {   int sele;
103     ElemType R[N],T[N];
104     int n,k;
105     long  t1,t2;
106     double  tt;
107     srand(1);
108     for(int i=0;i<N;i++)  T[i]=rand();     //产生10000个随机数
109     print(T,N);
110     printf("\n\n\n\n");
111     printf("\t\t       排序 子系统\n");
112     printf("\t\t*****************************\n");
113     printf("\t\t*     1----直接插入排序    *\n");
114     printf("\t\t*     2----二分插入排序   *\n");
115     printf("\t\t*     3----冒 泡 排 序    *\n");
116     printf("\t\t*     4----直接选择排序   *\n");
117     printf("\t\t*     5------  希尔排序   *\n");
118     printf("\t\t*     6------- 快速排序   *\n");
119     printf("\t\t*     6------- 排序   *\n");
120     printf("\t\t*     0----返  回      *\n");
121     printf("\t\t*****************************\n");
122     do
123     {
124         printf("\t\t   请选择菜单项(0-6):");
125         scanf("%d",&k);
126            for(int i=0;i<N;i++)  R[i]=T[i];
127         t1=time(NULL);
128         switch(k)
129         {    case 1:
130             insertsort(R,N);
131             t2=time(NULL);tt=difftime(t2,t1);
132             cout<<"直接插入排序的时间是:";
133             cout<<tt<<endl;
134             break;
135         case 2:
136             BinaryInsertSort(R,N);
137             t2=time(NULL);tt=difftime(t2,t1);
138              cout<<"二分插入排序的时间为:"<<tt<<endl;break;
139         case 3:
140             Bubblesort(R,N);
141             t2=time(NULL);tt=difftime(t2,t1);
142              cout<<"冒泡排序的时间为:"<<tt<<endl;break;
143         case 4:
144             selectsort(R,N);
145             t2=time(NULL);tt=difftime(t2,t1);
146              cout<<"直接选择排序的时间为:"<<tt<<endl;
147         case 5:
148             Shellsort(R,N);
149             t2=time(NULL);tt=difftime(t2,t1);
150             cout<<"希尔排序的时间为:"<<tt<<endl;break;
151             case 6:
152             quicksort(R,0,N);
153             t2=time(NULL);tt=difftime(t2,t1);
154             cout<<"快速排序的时间为:"<<tt<<endl;break;
155        }
156     }while(k);
157
158 }

原文地址:https://www.cnblogs.com/zongyao/p/9255397.html

时间: 2024-10-19 15:21:54

数据结构--实验5---排序(c)的相关文章

SDUT 3404 数据结构实验之排序七:选课名单.!?

数据结构实验之排序七:选课名单 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Problem Description 随着学校规模的扩大,学生人数急剧增加,选课名单的输出也成为一个繁重的任务,我校目前有在校生3万多名,两千多门课程,请根据给定的学生选课清单输出每门课的选课学生名单. Input 输入第一行给出两个正整数N( N ≤ 35000)和M(M ≤ 2000),其中N是全校学生总数,M是课程总数,随后给出N行,每行包括

SDUT 3403 数据结构实验之排序六:希尔排序

数据结构实验之排序六:希尔排序 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Problem Description 我们已经学习了各种排序方法,知道在不同的情况下要选择不同的排序算法,以期达到最好的排序效率:对于待排序数据来说,若数据基本有序且记录较少时, 直接插入排序的效率是非常好的,希尔排序就是针对一组基本有序的少量数据记录进行排序的高效算法.你的任务是对于给定的数据进行希尔排序,其中增量dk=n/(2^k)(k=1,2

SDUT 3399 数据结构实验之排序二:交换排序

数据结构实验之排序二:交换排序 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Problem Description 冒泡排序和快速排序都是基于"交换"进行的排序方法,你的任务是对题目给定的N个(长整型范围内的)整数从小到大排序,输出用冒泡和快排对这N个数排序分别需要进行的数据交换次数. Input 连续多组输入数据,每组数据第一行给出正整数N(N ≤ 10^5),随后给出N个整数,数字间以空格分隔. Output

SDUT 3398 数据结构实验之排序一:一趟快排

数据结构实验之排序一:一趟快排 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Problem Description 给定N个长整型范围内的整数,要求输出以给定数据中第一个数为枢轴进行一趟快速排序之后的结果. Input 连续输入多组数据,每组输入数据第一行给出正整数N(N < = 10^5),随后给出N个长整型范围内的整数,数字间以空格分隔. Output 输出一趟快速排序后的结果,数字间以一个空格间隔,行末不得有多余空格.

数据结构实验之排序八:快速排序

数据结构实验之排序八:快速排序 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Problem Description 给定N(N≤10^5)个整数,要求用快速排序对数据进行升序排列,注意不得使用STL. Input 连续输入多组数据,每组输入数据第一行给出正整数N(≤10^5),随后给出N个整数,数字间以空格分隔. Output 输出排序后的结果,数字间以一个空格间隔,行末不得有多余空格. Example Input 8 49

SDUT 3401 数据结构实验之排序四:寻找大富翁

数据结构实验之排序四:寻找大富翁 Time Limit: 200 ms Memory Limit: 512 KiB Problem Description 2015胡润全球财富榜调查显示,个人资产在1000万以上的高净值人群达到200万人,假设给出N个人的个人资产值,请你快速找出排前M位的大富翁. Input 首先输入两个正整数N( N ≤ 10^6)和M(M ≤ 10),其中N为总人数,M为需要找出的大富翁数目,接下来给出N个人的个人资产,以万元为单位,个人资产数字为正整数,数字间以空格分隔.

SDUT-3399_数据结构实验之排序二:交换排序

数据结构实验之排序二:交换排序 Time Limit: 1000 ms Memory Limit: 65536 KiB Problem Description 冒泡排序和快速排序都是基于"交换"进行的排序方法,你的任务是对题目给定的N个(长整型范围内的)整数从小到大排序,输出用冒泡和快排对这N个数排序分别需要进行的数据交换次数. Input 连续多组输入数据,每组数据第一行给出正整数N(N ≤ 10^5),随后给出N个整数,数字间以空格分隔. Output 输出数据占一行,代表冒泡排序

SDUT-3398_数据结构实验之排序一:一趟快排

数据结构实验之排序一:一趟快排 Time Limit: 1000 ms Memory Limit: 65536 KiB Problem Description 给定N个长整型范围内的整数,要求输出以给定数据中第一个数为枢轴进行一趟快速排序之后的结果. Input 连续输入多组数据,每组输入数据第一行给出正整数N(N < = 10^5),随后给出N个长整型范围内的整数,数字间以空格分隔. Output 输出一趟快速排序后的结果,数字间以一个空格间隔,行末不得有多余空格. Sample Input

数据结构-实验六 排序

实验六   排序   l  实验目的 1.排序的基本概念 1.掌握在数组上进行各种排序的方法和算法. 2.深刻理解各种方法的特点,并能灵活应用. 3.加深对排序的理解,逐步培养解决实际问题的编程能力. l  实验内容 1.排序的基本概念 (一)基础题 1.编写各种排序方法的基本操作函数: (1)s_sort(int e[],int n)选择排序: (2)si_sort(int e[],int n)直接插入排序: (3)sb_sort(int e[],int n)冒泡排序: (4)merge(in

数据结构实验4(排序算法的实现及性能分析)

实现了选择排序, 插入排序, 冒泡排序, 快速排序, 改进后的快速排序, 以及两路合并排序. 通过随机函数随机生成100个数, 进行各种排序, 记录排序开始时间以及结束时间, 计算消耗的时间来比较算法的优略. 实现代码: #include "iostream" #include "cstdio" #include "cstring" #include "algorithm" #include "queue"