各种排序方法的Ｃ语言实现

最新推荐文章于 2021-05-28 10:35:51 发布
最新推荐文章于 2021-05-28 10:35:51 发布
阅读量3k 收藏 6
点赞数
分类专栏： 数据结构 文章标签： 语言 system input shell struct 优化

 对顺序表用Ｃ语言实现直接插入排序、折半插入排序、希尔排序、快速排序、选择排序、冒泡优化排序、堆排序，代码如下：

 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <time.h>
#include <conio.h>
#define MAXSIZE 100
typedef int RedType;
typedef struct SqList
{
       RedType INT[MAXSIZE+1];
       int length;     
}SqList;
SqList L;
void TIME()                                      //获得系统时间
{
 static char *week[]={"一","二","三","四","五","六","日"};
 time_t t;
 struct tm *tp;
 t=time(NULL);
 tp=localtime(&t);
 printf("/t　       ─────────────────────/n");
 printf("/t/t    现在是:%d年%d月%d日",tp->tm_year+1900,tp->tm_mon+1,tp->tm_mday);  
 printf(" %d:%d:%d ",tp->tm_hour,tp->tm_min,tp->tm_sec,tp->tm_wday);
 printf("星期%s/n",week[(tp->tm_wday)-1]);
}
void PRINT(SqList *L)                             //打印排序结果
{
 int i;
 printf("/t/t");
 for(i=1;i<=L->length;i++)
     printf("%d ",L->INT[i]);
 printf("/n");
}
void STINSORT(SqList *L)                         //直接插入排序
{
 int i,j;
 for(i=2;i<=L->length;i++)                    //依次插入INT[2]，…，INT[n]
 {
  L->INT[0]=L->INT[i];                     //以INT[0]为哨兵
  j=i-1;
  while(L->INT[j]>L->INT[0])
  {
   L->INT[j+1]=L->INT[j];
   j--;
  }
  L->INT[j+1]=L->INT[0];
 }
}
void BIS_INT(SqList *L)                          //折半插入排序
{ 
 int i,j,low,high,mid;
 for(i=2;i<=L->length;++i)
       if(L->INT[i]<L->INT[i-1])
    {
     L->INT[0] = L->INT[i];
     high=i-1;                             //认为在r[1]和r[i-1]之间已经有序
     low=1;
     while(low<=high)                      //对有序表进行折半查找
     {
      mid=(low+high)/2;
      if(L->INT[0]<L->INT[mid])
       high=mid-1;
      else
       low=mid+1;
     }
     for(j=i-1;j>=high+1;--j)
      L->INT[j+1]=L->INT[j];
     L->INT[high+1]=L->INT[0];
    }
}
void SHELL(SqList *L)                            //希尔排序
{
 int i,j,d;
 d=L->length/2;                               //d为增量
 while(d>=1)                                  //最后一次的增量一定为1
 {
  for(i=d+1;i<=L->length;i++)
  {
   L->INT[0]=L->INT[i];
   j=i-d;
   while(L->INT[j]>L->INT[0]&&j>0)
   {
    L->INT[j+d]=L->INT[j];
    j=j-d;
   }
   L->INT[j+d]=L->INT[0];
  }
  d=d/2;
 }
}
void QUICK(SqList *L,int low,int high)           //快速排序
{
 int i,j,temp;
 i=low;
 j=high;
 temp=L->INT[low];                            //以INT[0]为基准
 while(i<j)                                   //从两端往中间进行扫描直到i=j为止
 {
  while(i<j&&temp<=L->INT[j])              //右端进行扫描
   j--;
  if(i<j)
  {
   L->INT[i]=L->INT[j];
   i++;
  }
  while(i<j&&L->INT[i]<=temp)              //左端进行扫描
   i++; 
  if(i<j)
  {
   L->INT[j]=L->INT[i];
   j--;
  }
 }
 L->INT[i]=temp;
 if(low<i)
  QUICK(L,low,i-1);                        //对左区间进行排序
 if(i<high)
  QUICK(L,j+1,high);                       //对右区间进行排序
}
void SELECT(SqList *L)                           //选择排序
{
 int i,j,small;
 for(i=1;i<=L->length-1;i++)                  //做第i趟排序(1≤i≤length-1)
 {
  small=i;                                 //保存小址
  for(j=i+1;j<=L->length;j++)              //在当前无序区INT[i..length]中选最小的记录INT[small]
  {
   if(L->INT[j]<L->INT[small])
    small=j;                         //small记下目前找到的最小关键字所在的位置
  }
  if(small!=i)                             //交换值
  {L->INT[0]=L->INT[i];L->INT[i]=L->INT[small];L->INT[small]=L->INT[0];}
 }
}
void BUBBLE(SqList *L)                           //冒泡优化排序
{
 int i,j,flag=1;                              //i为扫描次数,flag标记为是否交换
 for(i=0;i<=L->length-1&&flag==1;i++)
 {
  flag=0;
  for(j=0;j<L->length-i;j++)
  {
   if(L->INT[j]>L->INT[j+1])
   {
    flag=1;
    L->INT[0]=L->INT[j];
    L->INT[j]=L->INT[j+1];
    L->INT[j+1]=L->INT[0];
   }
  }
 }
}
void BUILDHEAP(SqList *L,int k,int m)            //建立堆
{
 int i,x;
 x=L->INT[k];
 for(i=2*k;i<=m;i=i*2)
 {
  if(i<m&&L->INT[i]<L->INT[i+1])
   i++;
  if(x>L->INT[i]) break;                   //x应插入在位置k上
  L->INT[k]=L->INT[i];
  k=i;
 }
 L->INT[k]=x;                                 //插入
}
void HEAPSORT(SqList *L)                         //堆排序
{
 int i,n,temp;
 n=L->length;
 for(i=n/2;i>0;i--)
  BUILDHEAP(L,i,n);
 for(i=n;i>1;i--)
 {
  temp=L->INT[1];
  L->INT[1]=L->INT[i];
  L->INT[i]=temp;  
  BUILDHEAP(L,1,i-1);                      //将INT[1..n-1] 重新调整为大顶堆
 }
}
void RAND(SqList *L)                             //随机生成数字
{
 int i;
 L->length=(rand()%(14))+2;                   //长度<=15,数值>=2的随机数
 for(i=0;i<L->length;i++)
 {
  //rand((unsigned)time(NULL));            //长度为65535以内的随机数
  L->INT[i]=(rand()%(100))+1;              //为0-100的随机数  
 }
}
void INIT(SqList *L)                             //初始化排序的数据
{
 int i;
 char c;
loop:;
 TIME();
 printf("/t　       ─────────────────────/n");
 printf("/n/t/t/t请输入待排序数据的数量【>=2】: ");
 while (scanf("%d", &L->length)!=1)           //检测是否为正确输入数
 {
  while ((c=getchar())!='/n');
  printf("/n/t/t【×】Error:错误的输入,请按任意键重新输入→/n/t/t/t/t");
  getch();
  system("cls");
  goto loop;
 }
 if(L->length<2||L->length>MAXSIZE)
 {
  printf("/n/t/t/t/t 【×】Error:/n/t/t待排序数据数目小于2或超出最大输入量,请按任意键重新输入→/n/t/t/t/t");
  getch();
  system("cls");
  goto loop;
 }
 printf("/n");
 for(i=1;i<=L->length;i++)
 {

   printf("/t/t/t    请输入第%d个数据: ",i);
lable:;  
   while (scanf("%d",&L->INT[i])!=1)          //检测是否为正确输入数
   {
    while ((c=getchar())!='/n');
    printf("/n【×】Error:数据输入出错,请重新输入→");
    goto lable;
   }
 }
 printf("/n/n/n/n/t/t/t数据初始化成功,按任意键继续→/n");
 getch();
 system("cls");
}
void PRIN()                                      //格式化输出─
{
 int i;
 printf("/t/t");
 for(i=0;i<L.length;i++)
  printf("──");
 printf("/n");
}
int MENUE()
{
 int input_data;
 char c;
 TIME();
 printf("/t　     ╭─────────────────────╮/n");
    printf("/t       ｜          各种排序的基本操作实现          ｜/n");
    printf("/t　     ｜─────────────────────｜/n");
    printf("/t       ｜          1、手动(Hand)输入数据           ｜/n");
    printf("/t　     ｜─────────────────────｜/n");
 printf("/t       ｜          2、随机(Rand)生成数据           ｜/n");
    printf("/t　     ｜─────────────────────｜/n");
    printf("/t       ｜          3、退         出  ...           ｜/n");
    printf("/t       ╰─────────────────────╯/n");
 printf("/t                        请正确选择:");
 while(scanf("%d", &input_data)!=1)                  //检测是否为正确输入数
 {
  while ((c=getchar())!='/n');
  return input_data;
 }
 fflush(stdin);
 return input_data;
}
void SUB_MENUE()
{
 char c;
 for(;;){
 TIME();
    printf("/t　     ╭─────────────────────╮/n");
    printf("/t       ｜          各种排序的基本操作实现          ｜/n");
    printf("/t　     ｜─────────────────────｜/n");
    printf("/t       ｜          1、重新(Again)输入数据          ｜/n");
    printf("/t       ｜          2、折半(Binary)排序             ｜/n");
    printf("/t       ｜          3、直接(Straight)排序           ｜/n");
 printf("/t       ｜          4、希尔(Shell)排序              ｜/n");
 printf("/t       ｜          5、快速(Quick)排序              ｜/n");
 printf("/t       ｜          6、选择(Select)排序             ｜/n");
 printf("/t       ｜          7、冒泡(Bubble)排序             ｜/n");
 printf("/t       ｜          8、堆  (Heap)排序               ｜/n");
 printf("/t       ｜          9、随机(Rand)生成               ｜/n");
    printf("/t       ｜          Q、退     出  ...               ｜/n");
    printf("/t       ╰─────────────────────╯/n");
 printf("/t        【共%d个数据】如下:/n",L.length);
 PRIN();
 PRINT(&L);
 PRIN();
    printf("/t                        请选择:");
    scanf("%s",&c);
 switch(c)
 {
  case '1':
   system("cls");
   INIT(&L);
   system("cls");
   break;
  case '2':
   BIS_INT(&L);
   printf("/n/t/t/t         排序成功!!!/n/t/t/t    ");
   system("pause");
   system("cls");
   break;
  case '3':
   STINSORT(&L);
   printf("/n/t/t/t         排序成功!!!/n/t/t/t    ");
   system("pause");
   system("cls");
   break;
  case '4':
   SHELL(&L);
   printf("/n/t/t/t          排序成功!/n/t/t/t     ");
   system("pause");
   system("cls");
   break;
  case '5':
   QUICK(&L,1,L.length);
   printf("/n/t/t/t          排序成功!/n/t/t/t     ");
   system("pause");
   system("cls");
   break;
  case '6':
   SELECT(&L);
   printf("/n/t/t/t          排序成功!/n/t/t/t     ");
   system("pause");
   system("cls");
   break;
  case '7':
   BUBBLE(&L);
   printf("/n/t/t/t          排序成功!/n/t/t/t    ");
   system("pause");
   system("cls");
   break;
  case '8':
   HEAPSORT(&L);
   printf("/n/t/t/t           排序成功!/n/t/t/t    ");
   system("pause");
   system("cls");
   break;
  case '9':
   RAND(&L);
   printf("/n/t/t/t         随机生成成功!/n/t/t/t   ");
   system("pause");
   system("cls");
   break;
  case 'q':
  case 'Q':
   system("cls");
   printf("/n/n/n/n/t/t/t   谢 谢 使 用 , 再 见!!!/n");
   printf("/n/t/t/t     任 意 键 退 出!/n/t/t/t");
   getch();
   exit(0);
   break;
  default :
   printf("/n/t/t/t/t 【×】Error:/n/t/t/t  输入有误,请重新选择!!!/n");
   getch();
   system("cls");
   break;
 }
 }
}
void main(void)
{ 
 int input_data;
 //kbhit();
 //puts("输入任意字符继续:");
 //while (!kbhit()) /* do nothing */ ;
 //puts("/r/n你按下了一个键!/r/n");
 do
 {
  input_data=MENUE();
  switch(input_data)
  {
  case 1:
   system("cls");
   INIT(&L);
   SUB_MENUE(); 
   break;
  case 2:
   system("cls");
   RAND(&L);
   SUB_MENUE(); 
   break;
  case 3:
   system("cls");
   printf("/n/n/n/n/t/t/t   谢 谢 使 用 , 再 见!!!/n");
   printf("/n/t/t/t     任 意 键 退 出!/n/t/t/t");
   getch();
   exit(0);
   break;
  default:
   printf("/n/t/t/t/t 【×】Error:/n/t/t/t  输入有误,请重新选择!!!/n");
   getch();
   system("cls");
   break;
  }
 }while(input_data!=3);
}

xnwyd
关注
专栏目录
C语言实现的五种基本的排序方法
03-29
用codeblocks用C语言实现的物种排序方法，从最基本的冒泡排序与选择排序，再到数据结构中所学的插入，快排与希尔排序
冒泡排序的C语言实现及详细说明.zip
最新发布
07-04
冒泡排序的C语言实现及详细说明.zip 冒泡排序的C语言实现及详细说明.zip 冒泡排序的C语言实现及详细说明.zip 冒泡排序的C语言实现及详细说明.zip 冒泡排序的C语言实现及详细说明.zip 冒泡排序的C语言实现及详细说明....
C语言实现各种排序
qq_33956112的博客
08-31 268
C语言实现各种排序 #include <stdio.h> #include <stdlib.h> #include <windows.h> //******************************************************** //直接插入排序 （稳定） //************************************...
所有的排序c语言实现
love coding
12-08 915
排序主要有两种，一种是n平方复杂度的，一种是nlogn或者n根号n的。 n平方复杂度的主要是一个一个将有序区间缩小，而nlogn或者根号n则是分区间的增大有序序列。 #include #include #include #include //在linux中，rand函数的最大值是32位字节，windows是16位字节 void swap(int32_t *a,int32_t
C语言实现各种排序（1）
各种排序算法的C语言实现
12-16 542
#include&lt;stdio.h&gt; //排序分为插入排序，希尔排序，冒泡排序，快速排序，选择排序，堆排序，归并排序，基数排序（桶排序） //1.1 //直接插入排序，较为简单，思路为从第二个数开始逐个将其插入前面有序的序列中 //平均时间复杂度为O(N2),最快时间复杂度为O(N),最坏时间复杂度为O(N2)，空间复杂度为O(1) void InsertSort(int *a,in...
基于C语言的几种常见排序方法
qq_52458004的博客
05-28 148
直接上代码： #include <iostream> #include <stdio.h> void bubble_sort(int *a,int len) { int i,j; int temp = 0; for(i = 0 ; i < len-1 ; i++) for(j = 0 ; j < len-1-i ; j++) { if(a[j]>a[j+1]) //如果顺序错误，就进行交换 { .
堆排序（C语言实现）
01-07
堆排序（C语言实现）算法思想步骤程序 算法思想 见： 4. 选择排序—堆排序（Heap Sort） 算法导论——堆排序heapsort 步骤 1. 将n个元素建立初始堆，第一个节点放在数组下标1中，因此n个节点对应数组 a[1] ~ a[n]，...
常用排序算法C语言实现
03-10
本资源"常用排序算法C语言实现"提供了一个实践平台，帮助学习者将理论知识转化为实际代码。 首先，让我们探讨几种常见的排序算法及其C语言实现： 1. **冒泡排序（Bubble Sort）**：冒泡排序是最基础的排序方法，...
C语言实现合并排序
01-21
　现在用递归算法，采用上面的分治思想来解合并排序。 　合并排序（非降序） 　分解：把合并排序分解成与两个子问题 　伪代码：  MERGE_SORT(A， begin， end)  if begin < end  then mid<- int...
C语言实现桶排序的方法示例
08-28
"C语言实现桶排序的方法示例" 桶排序是一种非比较排序算法，通过将输入数据分配到有限数量的桶中，然后对每个桶中的元素进行排序，最后依次连接桶中的元素以得到排序结果。本文将详细介绍C语言实现桶排序的方法，并...
各种排序算法的C语言实现源代码（全面）
04-02
各种排序算法的C语言实现源代码，算法导论上的各种排序算法的C语言实现源代码，很全面
直接插入、折半插入、冒泡、快速、简单选择等排序方法 用c语言实现
12-06
直接插入、折半插入、冒泡、快速、简单选择等排序方法 用c语言实现 代码运行正常 不会有任何的问题
快速排序来实现数组、链表的排序
04-22
快速排序时目前比较的好的排序方法，相比较的别排序法，例如冒泡法，选择法等等。
顺序表和链表的归并排序
10-17
顺序表和链表的归并排序，运用面向对象的思想，顺序表，链表继承线性表
几种简单的C语言排序方式（1）
Alone_qingyi的博客
01-05 323
冒泡排序 冒泡排序的原理是：从左到右，相邻元素进行比较。每次比较一轮，就会找到序列中最大的一个或最小的一个。这个数就会从序列的最右边冒出来。 以从小到大排序为例，第一轮比较后，所有数中最大的那个数就会浮到最右边；第二轮比较后，所有数中第二大的那个数就会浮到倒数第二个位置……就这样一轮一轮地比较，最后实现从小到大排序。 void fun(int *arr,int size) { for(int i=0;i<size-1;i++)//总共比较的大次数循环（例如9个数前一个和后一个比较总共比较8次） {
基本排序方法-选择排序和冒泡排序(来自:算法:C语言实现)
weixin_42480264的博客
08-14 428
选择排序 最简单的一种排序算法的工作过程如下.首先,选出数组中最小的元素,将它与数组中第一个元素进行交换.然后找出次小的元素,并将它与数组中第二个元素交换.按照这个方法一直进行下去,直到整个数组排完序.这种方法叫做选择排序,因为它是通过不断筛选出剩下元素中的最小元素来实现的. 冒泡排序 对于l~r-1内的i值,内部循环(j)通过从左向右遍历元素,对连续的元素进行比较-交换操作,实现将a[i]...
c语言大小排序流程图,各种排序的流程图 大家帮忙弄一下
weixin_26781975的博客
05-18 756
该楼层疑似违规已被系统折叠隐藏此楼查看此楼#include"stdio.h"#include"stdlib.h"arrin(int*a){inti,j;a[0]=rand()%10;for(i=1;i<10;i++){a[i]=rand()%10;for(j=0;jif(a[i]==a[j]){a[i]=rand()%10;j=0;}}}voidarrout(int...
c语言种必须掌握的四种排序方法
追风破雨
07-25 1715
    c语言中排序的方法有很多，就面试的可能性和使用的广度来说下面4种排序方法必须掌握，给出源代码：1.冒泡排序:(前两个直接在main()函数种实现)/************************************************ 函数名称: 冒泡排序* 作 者: 程凤明* 时 间: 2009-7-20*******************
C语言快速排序
09-27 321
#include <stdio.h> int main(){ printf("\n"); int list[]={5,2,1,6,9,8,3,4,7,}; //int list[]={2,6,3,5,4,}; int len=sizeof(list)/sizeof(list[0]); printf("原始数组为："); printL...
C语言实现各种排序算法详解
本资源提供了关于C语言中选择排序的详细讲解，包括基本思想、代码实现、效率分析以及优化方法，旨在帮助学习者深入理解排序算法并能实际应用。通过这些例子，学习者可以掌握选择排序的运作机制，并以此为基础探索更...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值