排序算法汇总

一、冒泡排序

算法思想:每次将剩余的最大的关键码,逐步上升放在最后一个位置,类似于冒泡。

#include<bits/stdc++.h>
using namespace std;
#define MAX 1001
int n,a[MAX];
void BubbleSort()
{
    for(int i=1;i<=n-1;i++){
        for(int j=1;j<=n-i;j++){
            if(a[j]<a[j+1]) continue;
            else{
                swap(a[j],a[j+1]);
            }
        }
    }
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    BubbleSort();
    for(int i=1;i<=n;i++) cout<<a[i]<<" ";
}
改进版冒泡排序:
#include<bits/stdc++.h>
using namespace std;
#define MAX 1001
int n,a[MAX];
void BubbleSort()
{
    for(int i=1;i<=n-1;i++){
        int num=0;
        for(int j=1;j<=n-i;j++){
            if(a[j]<a[j+1]) continue;
            else{
                swap(a[j],a[j+1]);
                num++;
            }
        }
        if(num==0) break;
    }
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    BubbleSort();
    for(int i=1;i<=n;i++) cout<<a[i]<<" ";
}

分析复杂度:
时间:O(n2)
空间:O(1)为交换是的辅助变量

二、选择排序

算法思想:每次选择剩余中最小的直接放到放到最前面

#include<bits/stdc++.h>
using namespace std;
#define MAX 10001
int n,a[MAX];
void Select()
{
    int tmp;
    for(int i=1;i<=n;i++){
        tmp=i;
        for(int j=i+1;j<=n;j++){
            if(a[j]<a[tmp]){
                tmp=j;
            }
        }
        swap(a[i],a[tmp]);
    }
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    Select();
    for(int i=1;i<=n;i++) cout<<a[i]<<" ";
}

时间复杂度:O(n2)
空间复杂度:O(1)

三、插入排序

算法思想:再前面的序列有序的情况下,不断将新的关键码放入

#include<bits/stdc++.h>
using namespace std;
#define MAX 1001
int n,a[MAX];
void InsertSort()
{
    for(int i=2;i<=n;i++){
        int tmp=i;
        for(int j=i-1;j>=1;j--){
            if(a[tmp]<a[j]){
                swap(a[tmp],a[j]);
                tmp=j;
            }
            else break;
        }
    }
    for(int i=1;i<=n;i++) cout<<a[i]<<" ";
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    InsertSort();
}

时间复杂度:O(n2)
空间复杂度:O(1)

四、希尔排序

基于插入排序,插入排序在数据基本有序的情况下复杂度大大降低,这是将序列分为n/k组,每组进行插入排序,然后逐渐缩小k,直到k=1完成。

#include<bits/stdc++.h>
using namespace std;
#define MAX 1001
int n,a[MAX];
void ShellSort()
{
    for(int d=n/2;d>=1;d/=2){
        for(int i=d;i<=n;i++){
            int tmp=i;
            for(int j=i;j>=1;j-=d){
                if(a[tmp]<a[j]){
                    swap(a[tmp],a[j]);
                    tmp=j;
                }
            }
        }
    }
    for(int i=1;i<=n;i++) cout<<a[i]<<" ";
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    ShellSort();
}

时间复杂度:nlog2n ~ O(n2)
空间复杂度:O(1)

五、归并排序

#include<bits/stdc++.h>
using namespace std;
#define MAX 1001
//归并排序
//原理:将两个有序的序列合并只需O(n)的时间复杂度
//      递归将序列分为两部分,当元素个数为1时开始合并
//      递归回溯将分开的序列合并,在子序列有序的前提下合并
int n,a[MAX],tmp[MAX];

//合并操作
void Merge(int l,int mid,int r){
    int i=l,j=mid+1,cnt=0;
    while(i<=mid&&j<=r){
        if(a[i]<a[j]){
            tmp[++cnt]=a[i++];
        }
        else tmp[++cnt]=a[j++];
    }
    while(i<=mid) tmp[++cnt]=a[i++];
    while(j<=r) tmp[++cnt]=a[j++];
    for(int i=l;i<=r;i++){
        a[i]=tmp[i-l+1];
    }
}

//递归划分
void MergeSort(int first,int last){
    if(first==last)return;
    int mid=(first+last)/2;
    MergeSort(first,mid);
    MergeSort(mid+1,last);
    Merge(first,mid,last);
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    MergeSort(1,n);
    for(int i=1;i<=n;i++) cout<<a[i]<<" ";
}

//复杂度分析
//空间复杂度:需要引用同样存储空间的辅助数组tmp,为O(n)
//时间复杂度:需要log n 趟排序,合并为O(n),这是最好、最坏的时间复杂度

六、快速排序

#include<bits/stdc++.h>
using namespace std;
#define MAX 10001
//快速排序
//以一个数位为基准,小于其的放在左边,大于其的放右边
//然后再递归基准左边、右边

int n,a[MAX];
int geti(int l,int r){
    int i=l,j=r;
    while(i<j){
        while(i<j&&a[i]<a[j]) j--;
        if(i<j){
            swap(a[i],a[j]);
            i++;
        }
        while(i<j&&a[i]<a[j]) i++;
        if(i<j){
            swap(a[i],a[j]);
            j--;
        }
    }
    return i;
}
void QuickSort(int l,int r){
    if(l>=r) return;
    int p=geti(l,r); 
    QuickSort(l,p-1);
    QuickSort(p+1,r);
}
int main()
{
    cin>>n;
    cout<<n<<endl;
    for(int i=1;i<=n;i++) cin>>a[i];
    QuickSort(1,n);
    for(int i=1;i<=n;i++) cout<<a[i]<<" ";
} 

时间复杂度:O(nlog2n ~ n2)
空间复杂度:O(1)

七、堆排序

#include<bits/stdc++.h>
using namespace std;
int a[10001],n;
//算法:堆排序
//大根堆:子节点小于父节点
//堆排序分为两部分 建堆、出堆

void shift(int i,int last)//调整堆
{
    int f=i,s=2*i;
    while(s<=last){
        if(s<last&&a[s]<a[s+1]) s++;
        //如果此时s=last,就没有右儿子,左儿子就是最大
        if(a[f]>a[s]) break;//此时已经调整完毕了
        else{
            swap(a[f],a[s]);
            f=s;
            s*=2;
        }
    }
}
void build()
{
    for(int i=n/2;i>=1;i--){
        //从第一个有子节点的结点开始建堆
        //保证无后效性
        if(a[i]<a[2*i]||a[i]<a[2*i+1]){
            shift(i,n);
        }
    }
}
void heapSort()
{
    build();
    for(int i=1;i<n;i++){
        swap(a[1],a[n-i+1]);
        //for(int j=1;j<=n;j++) cout<<a[j]<<" ";cout<<endl;
        shift(1,n-i);
        //for(int j=1;j<=n;j++) cout<<a[j]<<" ";cout<<endl;
        cout<<endl;
    }
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    heapSort();
}

时间复杂度:O(n log2n)~ n2
空间复杂度:O(1)

八、基数排序

对关键码进行分配与收集的思想进行排序

#include<bits/stdc++.h>
using namespace std;
#define MAX 1001

struct Node
{
    int data;
    Node* next;
};
int n,maxx,tmp,cnt;

Node* RadixSort(Node *first,int cnt){
    Node *head[10];
    Node *tail[13],*rear;
    int base=1;
    for(int i=1;i<=cnt;i++){
        for(int j=0;j<=9;j++) head[j]=tail[j]=NULL;
        while(first!=NULL){
            int c=((first->data)/base)%10;
            if(head[c]==NULL){
                head[c]=tail[c]=first;
            }
            else{
                tail[c]->next=first;
                tail[c]=first;
            }
            first=first->next;
        }
        for(int j=0;j<=9;j++){
            if(head[j]==NULL)continue;
            else{
                if(first==NULL){
                    rear=first=head[j];
                }
                else{
                    rear->next=head[j];
                }
                rear=tail[j];
            }
        }
        rear->next=NULL;
        base*=10;
    }
    Node *p=first;
    return first;
}
int main()
{
    cin>>n;
    Node *first,*rear,*p;
    first=rear=NULL;
    for(int i=1;i<=n;i++){
        cin>>tmp;
        p=new Node();
        p->data=tmp;
        if(first==NULL) first=rear=p;
        else{
            rear=rear->next=p;
        }
        maxx=max(tmp,maxx);
    }
    rear=rear->next=NULL;
    while(maxx){
        maxx/=10;
        cnt++;
    }
    first=RadixSort(first,cnt);
    p=first;
    while(p!=NULL){
        cout<<p->data<<" ";
        p=p->next;
    }
    cout<<endl;
}

时间复杂度:近乎线性O(n+m)
空间复杂度:O(m)

资源下载链接为: https://pan.quark.cn/s/3d8e22c21839 随着 Web UI 框架(如 EasyUI、JqueryUI、Ext、DWZ 等)的不断发展与成熟,系统界面的统一化设计逐渐成为可能,同时代码生成器也能够生成符合统一规范的界面。在这种背景下,“代码生成 + 手工合并”的半智能开发模式正逐渐成为新的开发趋势。通过代码生成器,单表数据模型以及一对多数据模型的增删改查功能可以被直接生成并投入使用,这能够有效节省大约 80% 的开发工作量,从而显著提升开发效率。 JEECG(J2EE Code Generation)是一款基于代码生成器的智能开发平台。它引领了一种全新的开发模式,即从在线编码(Online Coding)到代码生成器生成代码,再到手工合并(Merge)的智能开发流程。该平台能够帮助开发者解决 Java 项目中大约 90% 的重复性工作,让开发者可以将更多的精力集中在业务逻辑的实现上。它不仅能够快速提高开发效率,帮助公司节省大量的人力成本,同时也保持了开发的灵活性。 JEECG 的核心宗旨是:对于简单的功能,可以通过在线编码配置来实现;对于复杂的功能,则利用代码生成器生成代码后,再进行手工合并;对于复杂的流程业务,采用表单自定义的方式进行处理,而业务流程则通过工作流来实现,并且可以扩展出任务接口,供开发者编写具体的业务逻辑。通过这种方式,JEECG 实现了流程任务节点和任务接口的灵活配置,既保证了开发的高效性,又兼顾了项目的灵活性和可扩展性。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值