各种排序算法的一个类

#include<iostream>

#define MAX 100

using namespace std;

class Sample

{

int a[MAX];

int b[MAX];

int n;

friend class Process;

public:

Sample(){n=0;}

};

class Process

{

private:

int s_psort(Sample &s,int first,int end);

void sift(int k,int m,Sample &s);

public:

void getdata(Sample &s);

void s_isort(Sample &s);

void s_ssort(Sample &s);

void s_bsort(Sample &s);

void s_qsort(Sample &s,int first,int end);

void s_selsort(Sample &s);

void s_hsort(Sample &s);

void disp(Sample &s);

};

void Process::s_isort(Sample &s)

{

int temp;

for(int i=1;i<s.n;i++)

{

temp=s.a[i];

for(int j=i-1;j>=0&&temp<s.a[j];j--)

s.a[j+1]=s.a[j];

s.a[j+1]=temp;

}

}

void Process::s_ssort(Sample &s)

{

int temp;

for(int d=s.n/2;d>0;d=d/2)

{

for(int i=d;i<s.n;i++)

{

temp=s.a[i];

for(int j=i-d;j>=0&&temp<s.a[j];j=j-d)

s.a[j+d]=s.a[j];

s.a[j+d]=temp;

}

}

}

void Process::s_bsort(Sample &s)

{

int temp;

for(int i=0;i<s.n-1;i++)

for(int j=i+1;j<s.n;j++)

if(s.a[i]>s.a[j])

{

temp=s.a[i];

s.a[i]=s.a[j];

s.a[j]=temp;

}

}

int Process::s_psort(Sample &s,int first,int end)

{

int i=first,j=end,temp;

while(i<j)

{

while(i<j&&s.a[i]<=s.a[j])

j--;

if(i<j)

{

temp=s.a[i];

s.a[i]=s.a[j];

s.a[j]=temp;

i++;

}

while(i<j&&s.a[i]<=s.a[j])

i++;

if(i<j)

{

temp=s.a[i];

s.a[i]=s.a[j];

s.a[j]=temp;

j--;

}

}

return i;

}

void Process::s_qsort(Sample &s,int first,int end)

{

int p;

if(first<end)

{

p=s_psort(s,first,end);

s_qsort(s,first,p-1);

s_qsort(s,p+1,end);

}

}

void Process::s_selsort(Sample &s)

{

int temp,temp2;

for(int i=0;i<s.n-1;i++)

{

temp=i;

for(int j=i+1;j<s.n;j++)

if(s.a[temp]>s.a[j])

temp=j;

temp2=s.a[i];

s.a[i]=s.a[temp];

s.a[temp]=temp2;

}

}

void Process::sift(int k,int m,Sample &s)

{

int i=k,j=2*i+1,temp;

while(j<m)

{

if(j<m-2&&s.a[j]<s.a[j+1])// 体会j<m

j++;

if(s.a[i]>=s.a[j]) break;

else {

temp=s.a[i];

s.a[i]=s.a[j];

s.a[j]=temp;

i=j;

j=2*j+1;

}

}

}

void Process::s_hsort(Sample &s)

{

int temp;

for(int i=(s.n-1)/2;i>=0;i--)

sift(i,s.n,s);

for(int j=0;j<s.n-1;j++)

{

temp=s.a[0];

s.a[0]=s.a[s.n-j-1];

s.a[s.n-j-1]=temp;

sift(0,s.n-j-1,s);

}

}

void Process::getdata(Sample &s)

{

cout<<"元素个数:";

cin>>s.n;

for(int i=0;i<s.n;i++)

{

cout<<"输入第"<<i+1<<"个数据:";

cin>>s.a[i];

}

}

void Process::disp(Sample &s)

{

for(int i=0;i<s.n;i++)

cout<<s.a[i]<<" ";

cout<<endl;

}

int main()

{

int sel;

Sample s;

Process p;

p.getdata(s);

cout<<"原来序列:";

p.disp(s);

cout<<"1:插入排序 2:希尔排序 3:冒泡排序 4:快速排序 5:选择排序 6:堆排序 "<<endl;

cout<<"选择排序方法:";

cin>>sel;

switch(sel)

{

case 1:

p.s_isort(s);

cout<<"插入排序:";

break;

case 2:

p.s_ssort(s);

cout<<"希尔排序:";

break;

case 3:

p.s_bsort(s);

cout<<"冒泡排序:";

break;

case 4:

p.s_qsort(s,0,sel-1);

cout<<"快速排序:";

break;

case 5:

p.s_selsort(s);

cout<<"选择排序:";

break;

case 6:

p.s_hsort(s);

cout<<"堆排序:";

break;

}

p.disp(s);

return 0;

}

各种排序算法的一个类

时间: 2025-01-10 10:42:35

各种排序算法的一个类的相关文章

排序算法总结----比较类排序

概述:排序算法可分为比较性的排序,以及运算性的排序:这里详细介绍这些排序的原理,性能,实现,以及应用场合. 前面是维基百科的介绍,这里介绍几个比较典型的算法. 理论 计算复杂性理论 大O符号 全序关系 列表 稳定性 比较排序 自适应排序 排序网络 整数排序 交换排序 冒泡排序 鸡尾酒排序 奇偶排序 梳排序 侏儒排序 快速排序 臭皮匠排序 Bogo排序 选择排序 选择排序 堆排序 Smooth排序 笛卡尔树排序 锦标赛排序 循环排序 插入排序 插入排序 希尔排序 二叉查找树排序 图书馆排序 Pat

排序算法总结----运算类排序

运算排序 第一:计数排序 1:原理 对于每个输入数,确定小于该数的个数.这样可以直接把数放在输出数组的位置. 2:性能 最差时间复杂度 最优时间复杂度 平均时间复杂度 最差空间复杂度 注:稳定算法 3:应用 适合0~100的范围的数,当然可以和基排序结合而扩展数的范围. 4:实现 void CountingSort(int *A, int *B, int array_size, int k) { int i, value, pos; int * C=new int[k+1]; for(i=0;

详谈排序算法之选择类排序(两种方法实现堆排序)

   今天我们再来讨论一下选择类排序,选择类排序分为:简单排序,树形选择排序和堆排序.但我们主要说的是简单和堆排序两个,因为树形选择排序使用了较多的辅助空间,以及和∞进行多余比较,为弥补树型选择排序的这些缺点, J.W.J.Williams 在 1964 年提出了进一步的改进方法,即堆排序.对于我个人而言..一开始并不是很理解它的算法思想,纠结了许久.在网上查找资料的时候发现这位大神的文章思路十分清晰,而且把创建堆以及堆化数组的算法讲解的十分详细.如果有不明白堆排序思路的,可以先看看这篇文章~堆

详谈排序算法之插入类排序(两种思路实现希尔排序)

1. 排序( sorting) 的功能是将一个数据元素的任意序列,重新排列成一个按关键字有序的序列.其确切的定义为: 假设有n个数据元素的序列{R1 , R2 , - , Rn},其相应关键字的序列是{K1 , K2 , - , Kn} ,通过排序要求找出下标 1 , 2 , - , n的一种排列p1 , p2 , - , pn,使得相应关键字满足如下的非递减(或非递增)关系Kp1 ≤ Kp2 ≤ - ≤ Kpn这样,就得到一个按关键字有序的纪录序列{ Rp1 , Rp2 , - , Rpn }

详谈排序算法之交换类排序(两种方法实现快速排序【思路一致】)

1.冒泡排序    起泡排序的思想非常简单.首先,将 n 个元素中的第一个和第二个进行比较,如果两个元素的位置为逆序,则交换两个元素的位置:进而比较第二个和第三个元素关键字,如此类推,直到比较第 n-1 个元素和第 n 个元素为止:上述过程描述了起泡排序的第一趟排序过程,在第一趟排序过程中,我们将关键字最大的元素通过交换操作放到了具有 n 个元素的序列的最一个位置上.然后进行第二趟排序,在第二趟排序过程中对元素序列的前 n-1 个元素进行相同操作,其结果是将关键字次大的元素通过交换放到第 n-1

四种排序算法PHP实现类

四种排序算法的PHP实现:1) 插入排序(Insertion Sort)的基本思想是: 每次将一个待排序的记录,按其关键字大小插入到前面已经排好序的子文件中的适当位置,直到全部记录插入完成为止. 2) 选择排序(Selection Sort)的基本思想是: 每一趟从待排序的记录中选出关键字最小的记录,顺序放在已排好序的子文件的最后,直到全部记录排序完毕. 3) 冒泡排序的基本思想是: 两两比较待排序记录的关键字,发现两个记录的次序相反时即进行交换,直到没有反序的记录为止. 4) 快速排序实质上和

TimSort排序算法及一个问题分析

摘要 排序算法简析 代码入口 排序算法 获取两个有序数组A和B 找到待归并区间 准备操作 归并操作 TimSort的优化归并操作 问题解析 问题解析 问题原因 解决方案 参考 摘要 简单介绍了传统归并排序算法,以及Java API提供的TimSort优化后的归并排序算法. 并且分析了代码中出现的一个问题原因与解决方案. 敬请忽略文中的灵魂画风. 排序算法简析 代码入口 Collections.sort.List.sort.Arrays.sort方法是逐级调用的关系,最终的底层是Arrays.so

常见排序算法——七大比较类排序算法

算法 最坏复杂度 平均复杂度 最好复杂度 空间复杂度 选择排序 O($n^2$) O($n^2$) O($n^2$) O(1) 插入排序 O($n^2$) O($n^2$) O($n$) O(1) 希尔排序 O($nlog(n))$~O($n^2$) O($n^{1.3}$) O($n^2$) O(1) 冒泡排序 O($n^2$) O($n^2$) O(n)(用交换flag改进) O(1) 快速排序 O($n^2$) O($nlog(n)$) O($nlog(n)$) O(log(n))~O(n

常见的五类排序算法图解和实现(多关键字排序:基数排序以及各个排序算法的总结)

基数排序思想 完全不同于以前的排序算法,可以说,基数排序也叫做多关键字排序,基数排序是一种借助“多关键字排序”的思想来实现“单关键字排序”的内部排序算法. 两种方式: 1.最高位优先,先按照最高位排成若干子序列,再对子序列按照次高位排序 2.最低位优先:不必分子序列,每次排序全体元素都参与,不比较,而是通过分配+收集的方式. 多关键字排序 例:将下表所示的学生成绩单按数学成绩的等级由高到低排序,数学成绩相同的学生再按英语成绩的高低等级排序.        第一个关键字是数学成绩,第二个关键字是英