Sort

最新推荐文章于 2024-05-30 20:22:14 发布
最新推荐文章于 2024-05-30 20:22:14 发布
阅读量269 收藏
点赞数
分类专栏： DataStructure 文章标签： 算法 merge 数据结构 存储 ini
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/koppp1412/article/details/6010927
版权

数据结构：采用线性顺序表动态存储结构。

InsertSort:

 void insertSort(SqList &L)
 { /* 对顺序表L作直接插入排序。算法10.1 */
     clock_t start, end;
     start = clock();
     int i,j;
     for(i = 2; i <= L.length;++i)
     if LT( *(L.elem+i),*(L.elem+i-1)) /* "<",需将L.r[i]插入有序子表 */
     {
       *(L.elem) = *(L.elem+i); /* 复制为哨兵 */
       for(j=i-1;LT(*(L.elem),*(L.elem+j));--j)
     *(L.elem+j+1)=*(L.elem+j); /* 记录后移 */
       *(L.elem+j+1)=*(L.elem); /* 插入到正确位置 */
     }
     end = clock();
     cout<<"InsertSort Run time: "<<"/t"<<(double)(end - start) / CLOCKS_PER_SEC<<"S"<<endl;
 }

void bInsertSort(SqList &L)
 { /* 对顺序表L作折半插入排序。算法10.2 */
   clock_t start, end;
   start = clock();
   int i,j,m,low,high;
   for(i = 2; i <= L.length; ++i)
   {
     *(L.elem)=*(L.elem+i); /* 将L.r[i]暂存到L.r[0] */
     low=1;
     high=i-1;
     while(low<=high)
     { /* 在r[low..high]中折半查找有序插入的位置 */
       m=(low+high)/2; /* 折半 */
       if LT(*(L.elem),*(L.elem+m))
         high=m-1; /* 插入点在低半区 */
       else
         low=m+1; /* 插入点在高半区 */
     }
     for(j=i-1;j>=high+1;--j)
       *(L.elem+j+1)=*(L.elem+j); /* 记录后移 */
     *(L.elem+high+1)=*(L.elem); /* 插入 */
   }
   end = clock();
   cout<<"BInsertSort Run time: "<<"/t"<<(double)(end - start) / CLOCKS_PER_SEC<<"S"<<endl;
 }

void p2_InsertSort(SqList &L)
 { /* 2_路插入排序 */
    clock_t start, end;
    start = clock();
   int i,j,first,final;
   ElemType **d;
   d = (ElemType **)malloc(L.length*sizeof(ElemType)); /* 生成L.length个记录的临时空间 */
   d[0]= L.elem+1; /* 设L的第1个记录为d中排好序的记录(在位置[0]) */
   first = final = 0; /* first、final分别指示d中排好序的记录的第1个和最后1个记录的位置 */
   for(i = 2 ; i <= L.length; ++i)
   { /* 依次将L的第2个～最后1个记录插入d中 */
     if(*(L.elem+i) < *d[first])
     { /* 待插记录小于d中最小值，插到d[first]之前(不需移动d数组的元素) */
       first = (first-1 + L.length) % L.length; /* 设d为循环向量 */
       d[first] = L.elem+i;
     }
     else if(*(L.elem+i) > *d[final])
     { /* 待插记录大于d中最大值，插到d[final]之后(不需移动d数组的元素) */
       final=final+1;
       d[final] = L.elem+i;
     }
     else
     { /* 待插记录大于d中最小值，小于d中最大值，插到d的中间(需要移动d数组的元素) */
       j=final++; /* 移动d的尾部元素以便按序插入记录 */
       while(*(L.elem+i) < *d[j])
       {
         d[(j+1)% L.length] = d[j];
         j=(j-1+L.length)%L.length;
       }
       d[j+1]=L.elem+i;
     }
   }
   for(i=1;i<=L.length;i++) /* 把d赋给L.r */
     *(L.elem+i) = *d[(i+first-1)%L.length]; /* 线性关系 */
   end = clock();
   cout<<"P2_InsertSort Run time: "<<(double)(end - start) / CLOCKS_PER_SEC<<"S"<<endl;
 }
 void shellInsert(SqList &L,int dk)
 { /* 对顺序表L作一趟希尔插入排序。本算法是和一趟直接插入排序相比， */
   /* 作了以下修改： */
   /* 1.前后记录位置的增量是dk,而不是1; */
   /* 2.L.elem只是暂存单元,不是哨兵。当j<=0时,插入位置已找到。算法10.4 */
   int i,j;
   for(i = dk+1; i <= L.length; ++i)
     if LT(*(L.elem+i),*(L.elem+i-dk))
     { /* 需将L.elem+i插入有序增量子表 */
       *L.elem = *(L.elem + i); /* 暂存在L.elem */
       for(j = i-dk; j>0&&LT(*L.elem,*(L.elem+j));j-=dk)
         *(L.elem+j+dk) = *(L.elem+j); /* 记录后移，查找插入位置 */
       *(L.elem+j+dk) = *L.elem; /* 插入 */
     }
 }
 void shellSort(SqList &L,int dlta[],int t)
 { /* 按增量序列dlta[0..t-1]对顺序表L作希尔排序。算法10.5 */
   clock_t start, end;
   start = clock();
   int k;
   for(k=0;k<t;++k)
   {
     shellInsert(L,dlta[k]); /* 一趟增量为dlta[k]的插入排序 */
   }
   end = clock();
   cout<<"ShellSort Run time: "<<"/t"<<(double)(end - start) / CLOCKS_PER_SEC<<"S"<<endl;
 }

 

QuickSort:

//QuickSort 快速排序
void bubbleSort(SqList &L)
 { /* 将a中整数序列重新排列成自小至大有序的整数序列(冒泡排序)*/
   clock_t start, end;
   start = clock();
   int i,j;
   ElemType t;
   bool change;
   for(i = L.length-1, change = true; i >= 1 && change;--i)
   {
     change = false;
     for(j = 1; j <= i; ++j)
       if(L.elem[j]>L.elem[j+1])
       {
         t=L.elem[j];
         L.elem[j]=L.elem[j+1];
         L.elem[j+1]=t;
         change=true;
       }
   }
   end = clock();
   cout<<"BubbleSort Run time: "<<"/t"<<(double)(end - start) / CLOCKS_PER_SEC<<"S"<<endl;
 }

int partition(SqList &L,int low,int high)
 { /* 交换顺序表L中子表L.r[low..high]的记录，使枢轴记录到位， */
   /* 并返回其所在位置，此时在它之前(后)的记录均不大(小)于它。算法10.6(a) */
   ElemType t;
   ElemType pivotkey;
   pivotkey = L.elem[low]; /* 用子表的第一个记录作枢轴记录 */
   while(low<high)
   { /* 从表的两端交替地向中间扫描 */
     while(low<high&&L.elem[high]>=pivotkey)
       --high;
     t=L.elem[low]; /* 将比枢轴记录小的记录交换到低端 */
     L.elem[low]=L.elem[high];
     L.elem[high]=t;
     while(low<high&&L.elem[low]<=pivotkey)
       ++low;
     t=L.elem[low]; /* 将比枢轴记录大的记录交换到高端 */
     L.elem[low]=L.elem[high];
     L.elem[high]=t;
   }
   return low; /* 返回枢轴所在位置 */
 }

  void qSort(SqList &L,int low,int high)
 { /* 对顺序表L中的子序列L.r[low..high]作快速排序。算法10.7 */
   int pivotloc;
   if(low<high)
   { /* 长度大于1 */
     pivotloc = partition(L,low,high); /* 将L.r[low..high]一分为二 */
     qSort(L,low,pivotloc-1); /* 对低子表递归排序，pivotloc是枢轴位置 */
     qSort(L,pivotloc+1,high); /* 对高子表递归排序 */
   }
 }

 void quickSort(SqList &L)
 { /* 对顺序表L作快速排序。算法10.8 */
   clock_t start, end;
   start = clock();
   qSort(L,1,L.length);
   end = clock();
   cout<<"QuickSort Run time: "<<"/t"<<(double)(end - start) / CLOCKS_PER_SEC<<"S"<<endl;
 }
SelectSort:

// SelectionSort 选择排序
 int selectMinKey(SqList &L,int i)
 { /* 返回在L.r[i..L.length]中key最小的记录的序号 */
   ElemType min;
   int j,k;
   k = i; /* 设第i个为最小 */
   min = L.elem[i];
   for(j = i+1; j <= L.length; j++)
     if(L.elem[j] < min) /* 找到更小的 */
     {
       k = j;
       min = L.elem[j];
     }
   return k;
 }

 void selectSort(SqList &L)
 { /* 对顺序表L作简单选择排序。算法10.9 */
   clock_t start, end;
   start = clock();
   int i,j;
   ElemType t;
   for(i = 1; i < L.length; ++i)
   { /*  选择第i小的记录，并交换到位 */
     j = selectMinKey(L,i); /* 在L.r[i..L.length]中选择key最小的记录 */
     if(i != j)
     { /* 与第i个记录交换 */
       t=L.elem[i];
       L.elem[i]=L.elem[j];
       L.elem[j]=t;
     }
   }
   end = clock();
   cout<<"SelectSort Run time: "<<"/t"<<(double)(end - start) / CLOCKS_PER_SEC<<"S"<<endl;
 }

void treeSort(SqList &L)
 { /* 树形选择排序 */
   int i,j,j1,k,k1,l,n = L.length;
   ElemType *t;
   l = (int)ceil(log(n)/log(2))+1; /* 完全二叉树的层数 */
   k = (int)pow(2,l)-1; /* l层完全二叉树的结点总数 */
   k1 = (int)pow(2,l-1)-1; /* l-1层完全二叉树的结点总数 */
   t=(ElemType*)malloc(k*sizeof(ElemType)); /* 二叉树采用顺序存储结构 */
   for(i = 1; i <= n; i++) /* 将L.r赋给叶子结点 */
     t[k1+i-1]= L.elem[i];
   for(i = k1+n; i < k; i++) /* 给多余的叶子的关键字赋无穷大 */
     t[i] = INT_MAX;
   j1 = k1;
   j = k;
   while(j1)
   { /* 给非叶子结点赋值 */
     for(i=j1;i<j;i+=2)
       t[i]<t[i+1]?(t[(i+1)/2-1]=t[i]):(t[(i+1)/2-1]=t[i+1]);
     j = j1;
     j1 = (j1-1)/2;
   }
   for(i=0;i<n;i++)
   {
     L.elem[i+1]=t[0]; /* 将当前最小值赋给L.r[i] */
     j1=0;
     for(j=1;j<l;j++) /* 沿树根找结点t[0]在叶子中的序号j1 */
       t[2*j1+1] == t[j1]?(j1=2*j1+1):(j1=2*j1+2);
     t[j1]=INT_MAX;
     while(j1)
     {
       j1=(j1+1)/2-1; /* 序号为j1的结点的双亲结点序号 */
       t[2*j1+1]<=t[2*j1+2]?(t[j1]=t[2*j1+1]):(t[j1]=t[2*j1+2]);
     }
   }
   free(t);
 }

  void heapAdjust(HeapType &H,int s,int m) /* 算法10.10 */
 { /* 已知H.r[s..m]中记录的关键字除H.r[s].key之外均满足堆的定义，本函数 */
   /* 调整H.r[s]的关键字,使H.r[s..m]成为一个大顶堆(对其中记录的关键字而言) */
   ElemType rc;
   int j;
   rc = H.elem[s];
   for(j = 2*s; j <= m; j *= 2)
   { /* 沿key较大的孩子结点向下筛选 */
     if(j < m&&LT(H.elem[j],H.elem[j+1]))
       ++j; /* j为key较大的记录的下标 */
     if(!LT(rc,H.elem[j]))
       break; /* rc应插入在位置s上 */
     H.elem[s] = H.elem[j];
     s = j;
   }
   H.elem[s] = rc; /* 插入 */
 }

 void heapSort(HeapType &H)
 { /* 对顺序表H进行堆排序。算法10.11 */
   clock_t start, end;
   start = clock();
   ElemType t;
   int i;
   for(i = H.length/2; i > 0; --i) /* 把H.r[1..H.length]建成大顶堆 */
     heapAdjust(H,i,H.length);
   for(i = H.length; i > 1; --i)
   { /* 将堆顶记录和当前未经排序子序列H.r[1..i]中最后一个记录相互交换 */
     t = H.elem[1];
     H.elem[1] = H.elem[i];
     H.elem[i] = t;
     heapAdjust(H,1,i-1); /* 将H.r[1..i-1]重新调整为大顶堆 */
   }
   end = clock();
   cout<<"HeapSort Run time: "<<"/t"<<(double)(end - start) / CLOCKS_PER_SEC<<"S"<<endl;
 }

MergeSort:

 //MergingSort 归并排序
void merge(ElemType SR[],ElemType TR[],int i,int m,int n)
 { /* 将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n] 算法10.12 */
   int j,k,l;
   for(j = m+1, k = i; i <= m&&j <= n; ++k) /* 将SR中记录由小到大地并入TR */
     if LQ(SR[i],SR[j])
       TR[k] = SR[i++];
     else
       TR[k] = SR[j++];
   if(i <= m)
     for(l = 0; l <= m-i; l++)
       TR[k+l] = SR[i+l]; /* 将剩余的SR[i..m]复制到TR */
   if(j <= n)
     for(l = 0; l <= n-j; l++)
       TR[k+l] = SR[j+l]; /* 将剩余的SR[j..n]复制到TR */
 }

 void mSort(ElemType SR[],ElemType TR1[],int s, int t,long int n)
 { /* 将SR[s..t]归并排序为TR1[s..t]。算法10.13 */
   int m;
   ElemType *TR2;
   TR2 = (ElemType *)malloc(n*sizeof(ElemType));
   if(s == t)
     TR1[s] = SR[s];
   else
   {
     m = (s+t)/2; /* 将SR[s..t]平分为SR[s..m]和SR[m+1..t] */
     mSort(SR,TR2,s,m,n); /* 递归地将SR[s..m]归并为有序的TR2[s..m] */
     mSort(SR,TR2,m+1,t,n); /* 递归地将SR[m+1..t]归并为有序的TR2[m+1..t] */
     merge(TR2,TR1,s,m,t); /* 将TR2[s..m]和TR2[m+1..t]归并到TR1[s..t] */
   }
 }

 void mergeSort(SqList &L)
 { /* 对顺序表L作归并排序。算法10.14 */
   clock_t start, end;
   start = clock();
   ElemType *TR2;
   TR2 = (ElemType *)malloc(L.length*sizeof(ElemType));
   mSort(L.elem,L.elem,1,L.length,L.length);
   end = clock();
   cout<<"MergeSort Run time: "<<"/t"<<(double)(end - start) / CLOCKS_PER_SEC<<"S"<<endl;
 }

Mobius
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多目标跟踪算法 | DeepSort
黎国溥
02-09 3万+
前言 论文名称：（ICIP2017）Single-Simple Online and Realtime Tracking with a Deep Association Metric 论文地址：https://arxiv.org/abs/1703.07402 开源地址：https://github.com/nwojke/deep_sort 一、多目标跟踪的工作流程（常规） (1)给定视频的原始帧； (2)运行对象检测器以获得对象的边界框； (3)对于每个检测到的物体，计算出不同的特征.
SORT目标跟踪算法论文
09-07
SORT（Simple Online and Realtime Tracking）算法是一种针对多目标跟踪（Multiple Object Tracking，MOT）问题的高效实时方法。该算法由Alex Bewley等人在2017年发表的论文中提出，其主要关注在线实时应用中的目标...
sort
weixin_52895498的博客
05-17 1688
sort欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 sort()函数：对数组进行排序。 sort()函数在algorithm头文件中，注意，他的排序范围是[first,last),包括fi
Golang sort 排序
Dablelv 的博客专栏。
06-28 7293
1.前言 开发过程中，我们经常需要对元素进行排序，使用 Go 我们可以轻松实现。 Go 内置 sort 包中提供了根据一些排序函数可对任何序列进行排序，并提供自定义排序规则的能力。 sort 包实现了四种基本排序算法：插入排序（Shell 排序）、归并排序、堆排序和快速排序。 但是这四种排序方法是不公开的，它们只被用于 sort 包内部使用，sort 包会根据实际数据自动选择高效的排序算法。 Go sort 包主要提供了三种排序能力： （1）基本类型切片排序； （2）自定义比较器； （3）排序任意数据结构。
SORT与DeepSORT简介
qq_44733706的博客
02-20 2749
DeepSORT作为一个成熟多目标跟踪算法在很多应用中得到使用。本文对多目标跟踪算法SORT与DeepSORT做简要介绍。
Java Sort 方法的使用（包含Arrays.sort(),Collections.sort()以及Comparable，Comparator的使用 ）
最新发布
2302_79862386的博客
05-30 3142
Java Sort方法的使用
sort排序
qwer1404的博客
01-08 4261
sort可以用在数组的排序里 头文件algorithm要有 #include <iostream> #include<algorithm> using namespace std; int main() { int a[5] = { 3,9,4,6,5 }; sort(a, a + 5); for (int i = 0; i < 5; i++) cout << a[i] << ' '; return 0; } 原本数组a是乱序的 但
SORT跟踪算法的详细解释，不容错过
Scwabc_123的博客
04-08 1万+
转载自：https://blog.csdn.net/HaoBBNuanMM/article/details/85555547 原 【算法分析】SORT/Deep SORT 物体跟踪算法解析 2019年01月01日 20:21:26 HaoBBNuanMM 阅...
sort函数与结构体
hpu_yangchen的博客
08-23 4324
对于排序来说，c++的sort函数用着还是相当方便的，比什么冒泡排序，快速排序简单方便了很多。 sort函数的头文件是#include&lt;algorithm&gt; sort函数默认的排序方式是升序排序，即从小到大。   sort函数的使用 简单来说就是sort(begin,end,cmp); 对于cmp函数一会再说，begin就是开始排序的数字，end就是排序最后那个数； 如：...
sort函数用法
热门推荐
huqiaolong的博客
04-10 2万+
sort函数是一个非常强大的排序函数用法如下：//使用sort函数进行升序排序#include &lt;stdio.h&gt;#include &lt;algorithm&gt;//sort函数所在的函数库using namespace std;//sort所在的标准命名空间int main(){ int n; int i; int buffer[100]; while(~scanf("%d",&...
Scala 常用Sort排序
BITDDD小栈
08-20 2839
Scala 使用过程中经常要要用到排序模块，自带的方法有sorted，sortBy，sortWith，同时也提供了接口和类，例如Ordering，Ordered，Comparable，Comparator等，下面就盘一下他们的基本用法： 一.sorted 1.sorted-Default sorted 是基于Ordering 排序 /** Sorts this $coll according to an Ordering. * * The sort is stable. T.
Js sort排序使用方法
10-28
在JavaScript中，数组对象提供了一个非常有用的内置方法sort()，用于对数组中的元素进行排序。该方法接受一个函数作为参数，这个函数对于实现自定义排序规则至关重要。下面详细展开sort方法的使用方法以及相关的知识...
Deep Sort Pytorch
05-26
DeepSORT是一种常用的目标跟踪算法，它结合了深度学习和传统的目标跟踪方法。DeepSORT的核心思想是将深度学习的目标检测结果与传统的目标跟踪器相结合，实现在连续帧之间对目标的跟踪。 DeepSORT主要包括两个部分：...
vbs的sort排序
09-06
在VBScript（Visual Basic Script）中，`Sort`方法并不直接内置在语言中，因此，如果需要对数组进行排序，我们需要借助其他手段。在提供的代码示例中，使用了`System.Collections.ArrayList`对象来实现排序功能，这...
扑克牌发牌程序设计
10-15 3050
本程序实现了一般扑克牌游戏的洗牌、发牌和理牌过程，程序模拟了对四个玩家的发牌，且能让各自玩家按大小顺序整理自己的手牌。牌的大小顺序按斗地主的规则（但无大小王）。 本程序定义了一个牌的结构体，其成员变量是两个字符指针。一个指向点数的字符数组，另一个指向花色的字符数组。考虑到牌的整理需要比较两张牌的大小，而字符不太好比较，从而构造了一个辅助函数Value来实现将字符转换为整数。程序得最后还对桌牌和手牌进行了检测，看是否有重复的牌。
查并集（不相交数据结构）
02-22 1551
<br />用数组来表示森林T，parent[],<br />parent[x]表示x的父亲结点，若parent[x]==x则x为root<br />rank[]表示结点的深度<br />查并集有三个基本操作<br />make_set(x),创建以x为代表的集合<br />find(x),找到包含x集合的代表元素<br />union(x,y)将包含元素x和y的集合和并<br />参考算法导论该算法采用路径压缩技术和按秩合并<br />int parent[N],rank[N]; void make_s
赫夫曼编/译码系统
10-27 1170
利用赫夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。这要求在 发送端通过一个编码系统对待传输数据预先编码，在接收端将传来的数据进行译码（复原）。对于双工信道（即可以双向传输信息的信道），每端都需要有一个完整的编/译码系统。本文编写了一个简单的赫夫曼码的编/译码小程序。
Binary Tree Practise(二叉树面向对象编程)
10-20 674
理解二叉树的链式结构的存储 实现二叉树的基本函数 理解二叉树的遍历过程 能够针对递归结构的二叉树进行查询、修改、删除等操作
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值