C++排序（冒泡 选择 插入 桶 归并 快速）
1.排序
2.使用语言C++
3.系统 mac
4. IDE Clion
5.涉及排序 希尔排序（没有完成） 冒泡排序 桶排序 选择排序 快速排序 归并排序 插入排序 外加康托展开算法
完成且可用的排序
- 冒泡排序
- 选择排序
- 插入排序
- 桶排序
- 归并排序
- 快速排序
外加辅助的函数
7. 确定序列是有序的
8. 自动输入和输出
代码分为三部分
一个头文件
一个cpp
一个main
准确的说是2个部分‘
一个类 一个main
代码 头文件
#ifndef OPP_CSORT_CSORT_H
#define OPP_CSORT_CSORT_H
class Csort {
private:
int part(int* arr,int l,int r);
int aux[362880];
void MergeAux(int arr[],int l,int mid,int r);
long int factory[11]={1,1,2,6,24,120,720,5040,40320,362880,3628800};
bool Cantor(int arr[],int n);
bool isDeterministic(int arr[],int n);
public:
void ManualInput(int arr[],int n);
void AutoInput(int arr[],int n);
void AutoOut(int arr[],int n);
void Bubble(int arr[],int n);//冒泡排序
void Selection(int arr[],int n);//选择排序
void Shell(int arr[],int n);//希尔排序
void Insertion(int arr[],int n);//插入排序
void Merge(int arr[],int l,int r);//归并排序
void Quick(int arr[],int l,int r);//快速排序
void Bucket(int arr[],int n);//桶排序
void DeterministicSequence(int arr[],int n);//确定序列是排好的序列
void TestBubble(int arr[],int n);
void TestSelection(int arr[],int n);
void TestShell(int arr[],int n);
void TestInsertion(int arr[],int n);
void TestMerge(int arr[],int n);
void TestQuick(int arr[],int n);
void TestBucket(int arr[],int n);
};
#endif //OPP_CSORT_CSORT_H
代码 CPP
#include
#include "Csort.h"
using namespace std;
void Csort::ManualInput(int *arr, int n) {
for(int i=0;i>arr[i];
}
void Csort::AutoInput(int *arr, int n) {
for(int i=0;iarr[j+1]){
int t;
t=arr[i];
arr[i]=arr[j];
arr[j]=t;
}
}
}
void Csort::TestBubble(int arr[],int n) {
AutoInput(arr,n);
Bubble(arr,n);
AutoOut(arr,n);
}
void Csort::Selection(int *arr, int n) {
for(int i=0;iarr[j]){
int t;
t=arr[i];
arr[i]=arr[j];
arr[j]=t;
}
}
}
}
void Csort::TestSelection(int *arr, int n) {
AutoInput(arr,n);
Selection(arr,n);
AutoOut(arr,n);
}
void Csort::DeterministicSequence(int *arr, int n) {
if(isDeterministic(arr,n)) cout<<"Ture"<arr[i+1]) return 0;
return 1;
}
bool Csort::Cantor(int arr[],int n){
long res=0;
for(int i=0;iarr[j]){
++con;
}
}
res+=con*factory[n-i-1];//被选中的数后面还有几个数的全排列
}
if(res==0) return 1;
else return 0;
}
void Csort::Shell(int *arr, int n) {
int h=1;//希尔系数
while(h=1){//h 能等于1说明复杂度最坏能到O(n2)
for(int i=h;ih&&arr[j]0&&arr[j] arr[i]) min = i;
if(arr[max]0){arr[tt]=t;}
t++;tt++;
}
}
void Csort::TestBucket(int *arr, int n) {
AutoInput(arr,n);
Bucket(arr,n);
AutoOut(arr,n);
}
void Csort::Quick(int *arr, int l,int r) {
if(l>=r)
return;
int j=part(arr,l,r);
Quick(arr,l,j-1);
Quick(arr,j+1,r);
}
int Csort::part(int *arr, int l, int r) {
int i=l,j=r+1;
int v=arr[l];
while(1){
while(arr[++i]v) if(j==l) break;
if(i>=j) break;
int t;
t=arr[i];
arr[i]=arr[j];
arr[j]=t;
}
int t;
t=arr[l];
arr[l]=arr[j];
arr[j]=t;
return j;//切分位置 就是中心位置
}
void Csort::TestQuick(int *arr, int n) {
AutoInput(arr,n);
Quick(arr,0,n);
AutoOut(arr,n);
}
void Csort::Merge(int *arr, int l,int r) {
if(l>=r) return;
int mid=(l+r)/2;
Merge(arr,l,mid);
Merge(arr,mid+1,r);
MergeAux(arr,l,mid,r);
}
void Csort::MergeAux(int *arr, int l,int mid, int r) {
int i=l,j=mid+1;
for(int k=l;k<=r;k++)
aux[k]=arr[k];
for(int k=l;k<=r;k++){
if(i>mid) arr[k]=aux[j++];
else if(j>r) arr[k]=aux[i++];
else if(aux[i]>aux[j]) arr[k]=aux[j++];
else arr[k]=aux[i++];
}
}
void Csort::TestMerge(int *arr, int n) {
AutoInput(arr,n);
Merge(arr,0,n);
AutoOut(arr,n);
}
main函数主要自由发挥
#include
#include "Csort.h"
#include
int main() {
Csort csort;
int n=10000;
int a[n];
clock_t start,end;
csort.AutoInput(a,n);
csort.TestMerge(a,n);
return 0;
}
ctime头文件主要用到类clock_t
用来测试代码执行的时间 单位是ms
冒泡排序的实现
void Csort::Bubble(int *arr, int n) {
for(int i=0;iarr[j+1]){
int t;
t=arr[i];
arr[i]=arr[j];
arr[j]=t;
}
}
}
void Csort::TestBubble(int arr[],int n) {
AutoInput(arr,n);
Bubble(arr,n);
AutoOut(arr,n);
}
函数的声明都在Csort类里面 也就是头文件里面
第二个函数主要是用来测试这个算法
下面几个排序都是这个道理
选择排序的实现
void Csort::Selection(int *arr, int n) {
for(int i=0;iarr[j]){
int t;
t=arr[i];
arr[i]=arr[j];
arr[j]=t;
}
}
}
}
void Csort::TestSelection(int *arr, int n) {
AutoInput(arr,n);
Selection(arr,n);
AutoOut(arr,n);
}
插入排序的实现
桶排序的实现
void Csort::Bucket(int *arr, int n) {
int t=0;
int tt=0;
int min = 0;
int max=0;
for (int i = 0; i < n; i++){
if (arr[min] > arr[i]) min = i;
if(arr[max]0){arr[tt]=t;}
t++;tt++;
}
}
void Csort::TestBucket(int *arr, int n) {
AutoInput(arr,n);
Bucket(arr,n);
AutoOut(arr,n);
}
快速排序的实现
void Csort::Quick(int *arr, int l,int r) {
if(l>=r)
return;
int j=part(arr,l,r);
Quick(arr,l,j-1);
Quick(arr,j+1,r);
}
int Csort::part(int *arr, int l, int r) {
int i=l,j=r+1;
int v=arr[l];
while(1){
while(arr[++i]v) if(j==l) break;
if(i>=j) break;
int t;
t=arr[i];
arr[i]=arr[j];
arr[j]=t;
}
int t;
t=arr[l];
arr[l]=arr[j];
arr[j]=t;
return j;//切分位置 就是中心位置
}
void Csort::TestQuick(int *arr, int n) {
AutoInput(arr,n);
Quick(arr,0,n);
AutoOut(arr,n);
}
归并排序的实现
void Csort::Merge(int *arr, int l,int r) {
if(l>=r) return;
int mid=(l+r)/2;
Merge(arr,l,mid);
Merge(arr,mid+1,r);
MergeAux(arr,l,mid,r);
}
void Csort::MergeAux(int *arr, int l,int mid, int r) {
int i=l,j=mid+1;
for(int k=l;k<=r;k++)
aux[k]=arr[k];
for(int k=l;k<=r;k++){
if(i>mid) arr[k]=aux[j++];
else if(j>r) arr[k]=aux[i++];
else if(aux[i]>aux[j]) arr[k]=aux[j++];
else arr[k]=aux[i++];
}
}
void Csort::TestMerge(int *arr, int n) {
AutoInput(arr,n);
Merge(arr,0,n);
AutoOut(arr,n);
}
辅助函数的实现
void Csort::ManualInput(int *arr, int n) {
for(int i=0;i>arr[i];
}
void Csort::AutoInput(int *arr, int n) {
for(int i=0;iarr[i+1]) return 0;
return 1;
}
- 手动输入
- 自动输入
- 自动输出
- 判断序列是否有序 没有返回值
- 判断序列是否有序 有返回值 （但是我把他没有public）
康托展开算法的实现
bool Csort::Cantor(int arr[],int n){
long res=0;
for(int i=0;iarr[j]){
++con;
}
}
res+=con*factory[n-i-1];//被选中的数后面还有几个数的全排列
}
if(res==0) return 1;
else return 0;
}
以上所有函数的实现中出现的变量 等信息如果没有出现在函数内 均在类内声明
桶排序
唯一一个讲的 因为是我自己在刚开始学编程的时候想的第二个排序
第一个是冒泡 只有这两个是在没有看书的情况下 完全自主的想出来的’
代码
桶排序的实现
void Csort::Bucket(int *arr, int n) {
int t=0;
int tt=0;
int min = 0;
int max=0;
for (int i = 0; i < n; i++){
if (arr[min] > arr[i]) min = i;
if(arr[max]0){arr[tt]=t;}
t++;tt++;
}
}
void Csort::TestBucket(int *arr, int n) {
AutoInput(arr,n);
Bucket(arr,n);
AutoOut(arr,n);
}
桶排序的优点 算法复杂度是O(n)
缺点 只能是整形变量
运用了数组值和下标的转换 所以只能是整形变量 很大的缺点
范围-int的范围到+int的范围 应该是这个
初代的桶排序 （自己第一次想出来的）
只能是正数 和 0 很大的局限
但是 后来想想 0当做了坐标原点 但是坐标是可以移动的 如果把坐标原点放到数组的中央 岂不美哉
于是 算出数组中间的位置 即为变量mid 但是就算是知道了中间的位置 数组到底要多大 我们不知道 这里不想用动态数组 那咋整
于是 算出数组的最大和最小 最大-最小 当做数组的大小 保证接受数组的时候数组足够大 没保证避免不必要的空间 这样就能够比较灵活的使用了
但是还是有一个缺点 假设最大100 最小-100 数组就两个数 我们却得到了200的大小 数组的 浪费了很大空间 于是乎我们 我们需要其他函数的帮住
在 算出两中算法在问题规模为n的时候算法复杂度的函数图像都交点
那么n小使用前者算法 大的时候使用后者算法 就起到了很好的转换作用
更好的优化算法
大致就是这样子
算法看代码都能懂得
就不多说了额
全文至此共7947个字