总结：几种常见的内部排序方法

最新推荐文章于 2021-07-03 09:53:51 发布
最新推荐文章于 2021-07-03 09:53:51 发布
阅读量1.3k 收藏 2
点赞数
分类专栏： 数据结构与算法 文章标签： n2 merge struct 算法 存储
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/czlt86/article/details/1507035
版权

**************************************************************************************************** 

//直接插入排序,算法简洁，容易实现，时间复杂度O(N2),但较稳定，在基本有序和SIZE很小
//时是最好的排序方法
#include "stdio.h"
#include "stdlib.h"
#include "conio.h"
#include "time.h"
#define SIZE 10001

main()
{
 int num[SIZE],i,j;
 clock_t start,end;
 start=clock();
 randomize();
 for(i=1;i<SIZE;i++)
 {
  num[i]=rand()%10;
 }
 for(i=2;i<SIZE;i++)
 {
  if(num[i]<num[i-1])
  {
   num[0]=num[i];
   num[i]=num[i-1];
   for(j=i-2;num[0]<num[j+1];--j)
    num[j+1]=num[j];
   num[j+1]=num[0];
  }
 }
 end=clock();
 for(i=1;i<SIZE;i++)
  printf("%d/n",num[i]);
 printf("time:%.20f",(end-start)/CLK_TCK);
 getch();
}

**************************************************************************************************** 

//简单选择排序，属于选择排序，时间复杂度为O(N2)
#include "stdio.h"
#include "stdlib.h"
#include "conio.h"
#include "time.h"
#define SIZE 10001

main()
{
 int num[SIZE],i,j,seat,temp;
 clock_t start,end;
 start=clock();
 randomize();
 for(i=1;i<SIZE;i++)
  num[i]=rand()%10;
 for(i=SIZE-1;i>=1;i--)
 {
  seat=0;
  num[seat]=0;
  for(j=1;j<=i;j++)
  if(num[j]>num[seat]) seat=j;
  j--;
  temp=num[j];
  num[j]=num[seat];
  num[seat]=temp;
 }
 end=clock();
 for(i=1;i<SIZE;i++)
  printf("%d/n",num[i]);
 printf("time:%.20f",(end-start)/CLK_TCK);
 getch();
}

**************************************************************************************************** 

//希尔排序,属于插入排序，时间性能比较好，但不稳定
#include "stdio.h"
#include "stdlib.h"
#include "conio.h"
#include "time.h"
#define SIZE 10001

ShellInsert(int num[SIZE],int dk)
{
 int i,j;
 for(i=dk+1;i<=SIZE;++i)
 if (num[i]>num[i-dk])
 {
  num[0]=num[i];
  num[i]=num[i-dk];
  for(j=i-dk;j>0&&num[0]>num[j];j-=dk)
   num[j+dk]=num[j];
  num[j+dk]=num[0];
 }
}

main()
{
 int num[SIZE],i,j,dk=100;
 clock_t start,end;
 start=clock();
 randomize();
 for(i=1;i<SIZE;i++)
  num[i]=rand()%10000;
 for(i=dk;i>=1;i--)
 ShellInsert(num,i);
 end=clock();
 for(i=1;i<SIZE;i++)
  printf("%d/n",num[i]);
 printf("time:%.20f",(end-start)/CLK_TCK);
 getch();
}

**************************************************************************************************** 

//快速排序,属于借助交换进行排序的方法，就平均时间而言，是最好的内部排序方法，时间
//复杂度为O(N*LOG(N)),但若数列基本有序时，时间复杂度退化为O(N2),
#include "stdio.h"
#include "stdlib.h"
#include "conio.h"
#include "time.h"
#define SIZE 10001

partition(int num[SIZE],int low,int high)
{
 num[0]=num[low];
 while(low<high)
 {
  while(low<high&&num[high]>num[0]) --high;
  num[low]=num[high];
  while(low<high&&num[low]<=num[0]) ++low;
  num[high]=num[low];
 }
 num[low]=num[0];
 return low;
}

void Qsort(int num[SIZE],int low,int high)
{
 int pivotloc;
 if(low<high)
 {
  pivotloc=partition(num,low,high);
  Qsort(num,low,pivotloc-1);
  Qsort(num,pivotloc+1,high);
 }
}

main()
{
 int num[SIZE],i,j;
 clock_t start,end;
 start=clock();
 randomize();
 for(i=1;i<SIZE;i++)
  num[i]=rand()%1000;
 Qsort(num,1,SIZE-1);
 end=clock();
 for(i=1;i<SIZE;i++)
  printf("%d/n",num[i]);
 printf("time:%.20f",(end-start)/ CLK_TCK);
 getch();
}

**************************************************************************************************** 

//归并排序，时间复杂度为N(N*log(N)),最差情况也是，较为稳定，但实用性很差，较之堆排序
//在N较大时，所用时间较省，但辅助存储量较多
#include "stdio.h"
#include "stdlib.h"
#include "conio.h"
#include "time.h"
#define SIZE 10001

Merge(int sr[SIZE],int tr[SIZE],int i,int m,int n)
{
 int j,k;
 for(j=m+1,k=i;i<=m&&j<=n;++k)
 {
  if(sr[i]>sr[j])
  tr[k]=sr[i++];
  else
  tr[k]=sr[j++];
 }
 if(i<=m)
 for(;i<=m;i++,k++)
  tr[k]=sr[i];
 if(j<=n)
 for(;j<=n;j++,k++)
  tr[k]=sr[j];
}

MSort(int sr[SIZE],int tr1[SIZE],int s,int t)
{
 int tr2[SIZE],m;
 if(s==t) tr1[s]=sr[s];
 else
 {
  m=(s+t)/2;
  MSort(sr,tr2,s,m);
  MSort(sr,tr2,m+1,t);
  Merge(tr2,tr1,s,m,t);
 }
}

main()
{
 int num1[SIZE],num2[SIZE],i;
 clock_t start,end;
 start=clock();
 randomize();
 for(i=1;i<SIZE;i++)
  num1[i]=rand()%10;
 MSort(num1,num2,1,SIZE);
 end=clock();
 for(i=1;i<SIZE;i++)
  printf("%d/n",num2[i]);
 printf("time:%.20f",(end-start)/CLK_TCK);
 getch();
}

**************************************************************************************************** 

//堆排序，属于选择排序，时间复杂度为O(n*log(n)),最坏情况也是，但该方法对记录数较少
//的文件不值得提倡
#include "stdio.h"
#include "stdlib.h"
#include "conio.h"
#include "time.h"
#define SIZE 10001

HeapAdjust(int num[SIZE],int s,int m)
{
 int rc,j;
 rc=num[s];
 for(j=2*s;j<=m;j*=2)
 {
  if(j<m&&num[j]>num[j+1]) ++j;
  if(rc<=num[j]) break;
  num[s]=num[j];
  s=j;
 }
 num[s]=rc;
}

main()
{
 int num[SIZE],i,j,temp;
 clock_t start,end;
 start=clock();
 randomize();
 for(i=1;i<SIZE-1;i++)
  num[i]=rand()%1000;
 for(i=SIZE/2;i>0;--i)
  HeapAdjust(num,i,SIZE-1);
 for(i=SIZE-1;i>1;--i)
 {
  temp=num[1];
  num[1]=num[i];
  num[i]=temp;
  HeapAdjust(num,1,i-1);
 }
 end=clock();
 for(i=1;i<SIZE;i++)
  printf("%d/n",num[i]);
 printf("%.20f",(end-start)/CLK_TCK);
 getch();
}

**************************************************************************************************** 

//冒泡排序，属于借助交换进行排序的方法，时间复杂度为O(N2)
#include "stdio.h"
#include "stdlib.h"
#include "conio.h"
#include "time.h"
#define SIZE 10001

main()
{
 int num[SIZE],i,j,temp;
 clock_t start,end;
 start=clock();
 randomize();
 for(i=1;i<SIZE;i++)
  num[i]=rand()%1000;
 for(i=SIZE-1;i>=2;i--)
  for(j=1;j<i;j++)
   if(num[j]>num[j+1])
   {
    temp=num[j];
    num[j]=num[j+1];
    num[j+1]=temp;
   }
 end=clock();
 for(i=1;i<SIZE;i++)
 printf("%d/n",num[i]);
 printf("time:%.20f",(end-start)/CLK_TCK);
 getch();
}

**************************************************************************************************** 

//折半插入排序，属于简单排序，较之直接插入排序减少了关键字比较的次数，而移动的次数不变
#include "stdio.h"
#include "stdlib.h"
#include "conio.h"
#include "time.h"
#define SIZE 10001

main()
{
 int num[SIZE],i,j,low,mid,high;
 clock_t start,end;
 start=clock();
 randomize();
 for(i=1;i<SIZE;i++)
  num[i]=rand()%10000;
 for(i=2;i<SIZE;++i)
 {
  num[0]=num[i];
  low=1;
  high=i-1;
  while(low<high)
  {
   mid=(low+high)/2;
   if(num[0]<num[mid]) high=mid-1;
   else low=mid+1;
  }
  for(j=i-1;j>=high+1;--j)
  num[j+1]=num[j];
  num[high+1]=num[0];
 }
 end=clock();
 for(i=1;i<SIZE;i++)
  printf("%d/n",num[i]);
 printf("time:%.20f",(end-start)/CLK_TCK);
 getch();
}

**************************************************************************************************** 

//二路插入排序，属于简单排序，较之折半插入排序又减少了记录的移动次数，约为POW(N,2)/8
//但缺点是要付出多一倍的储存空间，并且当num[1]的元素为最小或最大，就完全失去优越性
#include "stdio.h"
#include "stdlib.h"
#include "conio.h"
#include "time.h"
#define SIZE 10000

main()
{
 int num[SIZE],temp[SIZE],index,i,first=1,final=1,mid;
 clock_t start,end;
 start=clock();
 randomize();
 for(i=0;i<SIZE;i++)
  num[i]=rand()%100;
 temp[final]=num[0];
 printf("/n");
 for(i=1;i<SIZE;i++)
 {
  if(num[i]>=temp[final])
   temp[++final]=num[i];
  else if(num[i]<=temp[first])
  {
   first=(first-1+SIZE)%SIZE;
   temp[first]=num[i];
  }
  else
  {
   for(index=(final-1+SIZE)%SIZE;;index=(index-1+SIZE)%SIZE)
   {
    if(temp[index]<=num[i])
    {
     mid=final++;
     while(mid!=index)
     {
      temp[(mid+1)%SIZE]=temp[mid];
      mid=(mid-1+SIZE)%SIZE;
     }
     temp[(index+1)%SIZE]=num[i];
     break;
    }
   }
  }
 }
 for(i=0;i<SIZE;++i)
 {
  num[i]=temp[first];
  first=(first+1)%SIZE;
 }
 end=clock();
 for(i=0;i<SIZE;i++)
  printf("%d/n",num[i]);
 printf("/ntime:%.20f",(end-start)/CLK_TCK);
 getch();
}

**************************************************************************************************** 

以下两种方法都用于记录所占空间较大时，因为他们都采取了以修改指针来代替移动记录

**************************************************************************************************** 

//表插入排序，属插入排序，该方法的时间复杂度为O(N2)
#include "stdio.h"
#include "stdlib.h"
#include "conio.h"
#include "time.h"
#define SIZE 10001

void TableSort(int num[SIZE],int temp[SIZE])
{
 int i,j,indexpr,index;
 temp[0]=1;
 temp[1]=0;
 num[0]=num[1];
 for(i=2;i<SIZE;i++)
 {
  if(num[i]>=num[0])
  {
   for(index=temp[0];index!=0;indexpr=index,index=temp[index]);
   temp[indexpr]=i;
   temp[i]=0;
   num[0]=num[i];
  }
  else if(num[i]<=num[temp[0]])
  {
   temp[i]=temp[0];
   temp[0]=i;
  }
  else
  {
   for(index=temp[0];index!=0;index=temp[index])
   {
    if (num[index]>num[i])
    {
     temp[i]=index;
     temp[indexpr]=i;
     break;
    }
    indexpr=index;
   }
  }
 }
}

void Arrange(int num[SIZE],int temp[SIZE])
{
 int index,q,t,i;
 index=temp[0];
 for(i=1;i<SIZE;i++)
 {
  while(index<i)
  index=temp[index];
  q=temp[index];
  if(index!=i)
  {
   t=num[i];
   num[i]=num[index];
   num[index]=t;
   temp[index]=temp[i];
   temp[i]=index;
  }
  index=q;
 }
}

main()
{
 int num[SIZE],temp[SIZE],i;
 clock_t start,end;
 start=clock();
 randomize();
 for(i=1;i<SIZE;i++)
  num[i]=rand()%100;
 TableSort(num,temp);
 Arrange(num,temp);
 end=clock();
 for(i=0;i<SIZE;i++)
  printf("%d/n",num[i]);
 printf("/ntime:%.20f",(end-start)/CLK_TCK);
 getch();
}

**************************************************************************************************** 

//基数排序，是一种与前面所有排序都不同的排序方法，该方法不需要进行关键字间的比较
//它是一种借助多关键字排序的思想对单逻辑关键字进行排序的方法，其时间复杂度为O(d*n)
//它最适合N值很大而关键字较小的序列，若关键字也很大，而序列中大多数记录的最高位关
//键字均不同，则亦可先按最高位关键字不同将需类分成若干小的子序列，而后进行直接插入排序
#include "stdio.h"
#include "stdlib.h"
#include "conio.h"
#include "time.h"
#define MAX_NUM_OF_KEY 1
#define RADIX 10
#define SIZE 11

typedef struct
{
 int keys[MAX_NUM_OF_KEY];
 int next;
}Node;

Distribute(Node array[SIZE],int i,int f[RADIX],int e[RADIX])
{
 int j,p,key;
 for(j=0;j<RADIX;j++)
  f[j]=0;
 for(p=array[0].next;p;p=array[p].next)
 {
  key=array[p].keys[i];
  if(!f[key])
   f[key]=p;
  else
   array[e[key]].next=p;
  e[key]=p;
 }
}

Collect(Node array[SIZE],int i,int f[RADIX],int e[RADIX])
{
 int j,t;
 for(j=0;!f[j];j++);
 array[0].next=f[j];
 t=e[j];
 while(j<RADIX)
 {
  for(j++;j<RADIX-1&&!f[j];j++);
   if(f[j])
   {
    array[t].next=f[j];
    t=e[j];
   }
 }
 array[t].next=0;
}

main()
{
 Node array[SIZE];
 int f[RADIX],e[RADIX],i;
 clock_t start,end;
 start=clock();
 randomize();
 for(i=0;i<SIZE-1;i++)
 {
  array[i+1].keys[0]=rand()%10;
  array[i].next=i+1;
 }
 array[SIZE-1].next=0;
 for(i=0;i<MAX_NUM_OF_KEY;i++)
 {
  Distribute(array,i,f,e);
  Collect(array,i,f,e);
 }
 end=clock();
 for(i=array[0].next;i;i=array[i].next)
  printf("%d/n",array[i].keys[0]);
 printf("time:%.20f",(end-start)/CLK_TCK);
 getch();
}

czlt86
关注
专栏目录
几种常见的内部排序
wust_cyl的博客
01-06 1万+
排序是计算机程序设计中的一种重要操作，它的功能是将一个数据元素的任意序列，重新排列成一个按关键字有序的序列。 排序分为内部排序和外部排序。 随着计算机的内存不断扩大和查找算法的不断优化，外部排序用到地方不多了。 设待排序的关键字序列为{12,2,16,30,28,10,16*,20,6,18} 1：直接插入排序：它的基本操作是将一个记录插入到已经排好序的有序表中，从而得到一个新的，
常见的几种内排序算法以及实现（C语言）
05-24
主要的内排序包括冒泡、插入、希尔、堆排序、归并、快速、桶排序等，本源码对其用C语言实现，并且进行了简答的测试，可以准确运行，其算法源码以及测试主程序都在源码文件main.c中
常见内部排序方法的总结
Leo_hello的博客
07-03 665
常见内部排序方法的总结 排序方法 时间复杂度（平均） 时间复杂度（最坏） 时间复杂度（最好） 空间复杂度 稳定性 插入排序 O(n2) O(n2) O(n) O(1) 稳定 希尔排序 O(nlog2n) O(n2) O(n) O(1) 不稳定 选择排序 O(n2) O(n2) O(n2) O(1) 不稳定 堆排序 O(nlog2n) O(nlog2n) O(nlog2n) O(1) 不稳定 冒泡排序 O(n2) O(n2) O(n) O(1) 稳定 快速排序 O(nlog
几种常见的内部排序方法
木瓜鹏的专栏
08-12 1809
常见内部排序总结 一、基本排序概念 1.1、排序：就是将一个元素的任意序列重新排成一个按关键字有序的序列。 1.2、稳定性：如果待排序表中有两个元素Ri、Rj，其对应关键字为Ki=Kj,且排序前Ri在Rj之前，如果使用某一排序算法后，Ri仍在Rj前面，则称这个排序方法是稳定的，否则称之为不稳定排序。 1.3、内部排序：排序期间，元素全部存放在内存中的排序。 1.4、外部排序：排序期间，元
常用的内部排序算法
zhuzhunvhai的博客
07-02 390
#include "stdio.h"#include "stdlib.h"#include "math.h"#define MaxSize 30 typedef  int  KeyType;typedef struct {        KeyType  key;}RecordType;//直接插入排序void InsertSort(RecordType r[], int length){    ...
数据结构：第10章 内部排序.ppt
06-16
本章提到了几种具体的内部排序算法： 1. 直接插入排序：这是一种简单直观的排序方法。它将待排序的数据分为已排序和未排序两部分，每次将未排序区的一个元素插入到已排序区的合适位置，直到所有元素都被插入。直接...
数据结构：第十章_内部排序.ppt
09-17
本章主要介绍了几种常见的内部排序算法，包括插入排序、快速排序、堆排序、归并排序和基数排序，并对这些排序方法进行了综合比较。 1. **插入排序**：插入排序是一种简单直观的排序算法，它的工作原理类似于打扑克...
数据结构教学课件：第九讲 内部排序3.ppt
06-16
数据结构教学课件的第九讲主要探讨了内部排序方法中的快速排序算法。快速排序是一种高效的分治算法，由英国计算机科学家C.A.R. Hoare在1960年提出。其基本思想是通过一趟排序将待排序的数据分割成独立的两部分，其中...
几种常见排序算法的实现
07-29
本文将深入探讨六种常见的排序算法：选择排序、插入排序、冒泡排序、希尔排序、快速排序以及归并排序，它们都是编程实践中不可或缺的基础知识。 1. **选择排序（Selection Sort）**： 选择排序的工作原理是每一次...
设计一个测试程序比较几种内部排序算法的关键字比较次数和移动次数以取得直观感受。
12-26
设计一个测试程序比较几种内部排序算法的关键字比较次数和移动次数以取得直观感受。 在本文中，我们将设计一个测试程序比较几种内部排序算法的关键字比较次数和移动次数，以取得直观感受。内部排序算法是指在内存中...
常用的内部排序方法-非比较排序
wl044090432的博客
01-22 657
这篇文章中我们来探讨一下常用的非比较排序算法：计数排序，基数排序，桶排序。在一定条件下，它们的时间复杂度可以达到O(n)。 　　这里我们用到的唯一数据结构就是数组，当然我们也可以利用链表来实现下述算法。     　　计数排序(Counting Sort)   　　计数排序用到一个额外的计数数组C，根据数组C来将原数组A中的元素排到正确的位置。 　　通俗地理
简述内部排序的各类排序方法
suorce的博客
09-07 900
排序分类 插入排序 直接插入排序 折半插入排序 表插入排序 希尔排序 交换排序 冒泡排序 快速排序 选择排序 简单选择排序 堆排序 归类排序 分配排序 多关键字排序 基数排序 直接插入排序 假设有n个记录需要排序，初始时直接插入排序认为只有第一个记录有序，后面的n-1个记录都是无序的，然后取无序的第一个元素，与有序的元素作顺序比较，将比他大的数后移一个位置，直到找到合适它的位...
【算法篇】八种内排序算法
cc的博客
07-03 2558
常用的八种内排序算法分别是： 交换排序：冒泡排序、快速排序 选择排序：简单选择排序、堆排序 插入排序：直接插入排序、希尔排序 归并排序 基数排序 内排序巧记：选(选择)舰(简单选择)队(堆)的时候脚(交换)毛(冒泡)快(快速)，需要把轨(归并)迹(基数)擦(插入)仔(直接插入)细(希尔) 一、冒泡排序 冒泡排序的基本思想是，对相邻的元素进行两两比较，顺序相反则进行交换，这样，每一趟会...
算法 - 内部排序方法总结
热门推荐
了解➔熟悉➔掌握➔精通
03-05 3万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 各种排序方法的性能比较 排序方法 最好时间复杂度 平均时间复杂度 最坏时间复杂度 空间复杂度 稳定性 直接插入排序 O(n) O(n2) O(n2) O(1) 稳定 简单选择排...
内部排序方法图解以及代码
Doigt_的博客
09-15 579
内部排序方法简单图解以及代码 1. 直接插入排序 直接插入排序是一种简单的排序方法，具体做法是：在插入第i个记录时，R1、R2、…、Ri-1已经排好序，这时将Ri的关键字Ki依次与关键字Ki-1、Ki-2等进行比较，从而找出应该插入的位置并将Ri插入，插入位置及其后的记录依次向后移动。 void Insertsort(int data[],int n) /*将数组data[0]~data[n-1]中的n个整数按非递减有序的方式进行排列*/ { int i,j; int tmp; for(i=1;i&l
常用的内部排序方法-比较排序
wl044090432的博客
01-22 5326
所谓的内排序是指所有的数据已经读入内存，在内存中进行排序的算法。排序过程中不需要对磁盘进行读写。同时，内排序也一般假定所有用到的辅助空间也可以直接存在于内存中。与之对应地，另一类排序称作外排序，即内存中无法保存全部数据，需要进行磁盘访问，每次读入部分数据到内存进行排序。
常见的排序方法有哪些？
cjwjyooo的博客
06-29 9785
大家好，我是IT修真院郑州分院第八期的学员，今天给大家分享一下，题目常见的排序方法有哪些。 一、背景介绍 排序算法（英语：Sorting algorithm）是一种能将一串资料依照特定排序方式进行排列的一种算法。最常用到的排序方式是数值顺序以及字典顺序。 查找和排序算法是算法的入门知识，其经典思想可以用于很多算法当中。因为其实现代码较短，应用较常见。 所以在面试中经常会问到排序算法及其相关的...
各种内排序方法的比较和选择
zmeilin的博客
07-26 2055
通常可按照平均时间复杂度将排序方法分为3类： 平方阶O（n2）排序，一般称为简单排序，例如直接插入排序、直接选择排序、冒泡排序 线性对数阶O（nlogn）排序，如快速排序，堆排序和归并排序 线性阶O（n）排序，如基数排序（假定数据的位数d和进制r为常量时）   各种排序方法的性能 排序方法 平均情况 最坏情况 最好情况 空间复杂度 稳定性 复杂性 ...
常见内部排序方法的比较以及选择
04-21 1662
影响排序效果的因素及排序方法的选择 ①  排序的记录数目n         若n较小（n直接选择排序或直接插入排序。当记录规模较小时，直接插入排序较好；否则，当直接选择移动的记录数少于直接插人时，直接选择排序为宜。         若n较大，则应采用时间复杂度为nlgn的排序方法：快速排序、堆排序或归并排序。         快速排序是目前基于比较的内部排序中被认为是最好的方法，当待排序的
排序算法解析：快速排序与多种内部排序方法
除了快速排序，描述中还提到了其他几种常见的内部排序算法： 1. 插入排序：对于小规模或者部分有序的数据，插入排序有很好的表现。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值