十大排序(知识篇)--纯手工代码

简介: 十大排序(知识篇)--纯手工代码
//
//冒泡排序
//
#include <bits/stdc++.h>
using namespace  std;
void bubbleSort(int arr[],int len){
   bool flag = false;
   for(int i=0;i<len-1;i++){
       flag = false;
       for(int j=0;j<len-i-1;j++){
           if(arr[j] > arr[j+1]){
               swap(arr[j],arr[j+1]);
               flag = true;
           }
       }
       if(!flag){
           break;
       }
   }
}
//
// 计数排序
//
#include <bits/stdc++.h>
using namespace std;
void countingSort(int arr[],int len){
    int maxn = 0;
    for(int i=0;i<len;i++){maxn = max(maxn,arr[i]);}
    int t = maxn;
    int *cen = new int[maxn+10];
    for(int i=0;i<=maxn;i++){cen[i] = 0;}
    for(int i=0;i<len;i++){cen[arr[i]]++;}
    for(int i=1;i<=maxn;i++){cen[i] += cen[i-1];}
    int *ans = new int[len];
    for(int i=0;i<len;i++){
        ans[cen[arr[i]]-1] = arr[i];
        cen[arr[i]]--;
    }
    for(int i=0;i<len;i++){
        arr[i] = ans[i];
    }
    delete []ans;
    delete []cen;
}
//堆排序
#include <bits/stdc++.h>
using namespace std;
int heapSize = 0;
int left(int x){
    if(2*x+1 >= heapSize) return -1;
    return 2*x+1;
}
int right(int x){
    if(2*x+2 >= heapSize) return -1;
    return 2*x+2;
}
void minHeapify(int arr[],int x){
    int L = left(x);
    int R = right(x);
    int mann = x;
    if(L != -1 && arr[L] > arr[mann]){mann = L;}
    if(R != -1 && arr[R] > arr[mann]){mann = R;}
    if(mann != x){
        swap(arr[x],arr[mann]);
        x = mann;
        minHeapify(arr,x);
    }
}
void Delete(int arr[]){
    swap(arr[heapSize-1],arr[0]);
    heapSize--;
    minHeapify(arr,0);
}
void heapSort(int arr[],int len){
    //建立大顶堆
    heapSize = len;
    for(int i=(len-1)/2;i>=0;i--){
        minHeapify(arr,i);
    }
    //从堆中取结点
    for(int i=0;i<len;i++){
        Delete(arr);
    }
}
//
// 直接插入排序
//
#include <bits/stdc++.h>
using namespace std;
void insertSort(int arr[],int len){
    for(int i=1;i<len-1;i++){
        int j   =  i-1;
        int key =  arr[i];
        while(j>=0 && arr[j] > key){
            arr[j+1] = arr[j];
            j--;
        }
        arr[j+1] = key;
    }
}
//
// 归并排序
//
#include <bits/stdc++.h>
using namespace std;
void merge(int arr[],int l,int r){
    int mid = (l+r)/2;
    int nL  =  mid-l+1;
    int nR  =  r-mid;
    //创建两个行的数组存放
    int *L = new int[nL];
    int *R = new int[nR];
    for(int i=0;i<nL;i++){L[i]=arr[l+i];}
    for(int i=0;i<nR;i++){R[i]=arr[i+mid+1];}
    int i=0,j=0;        //分别指向L和R
    for(int k=l;k<=r;k++){
        if(j>=nR || (i<nL && L[i]<=R[j])){
            arr[k] = L[i++];
        }else{
            arr[k] = R[j++];
        }
    }
}
void mergeSort(int arr[],int l,int r){
    if(l < r){
        int mid = (l+r)/2;
        mergeSort(arr,l,mid);
        mergeSort(arr,mid+1,r);
        merge(arr,l,r);
    }
}
//
// 鸽巢排序
//
#include <bits/stdc++.h>
using namespace std;
void pigeonSort(int arr[],int len){
    int k = 0;
    for(int i=0;i<len;i++){k = max(k,arr[i]);}
    int *cen = new int[k+10];
    for(int i=0;i<=k;i++){cen[i]=0;}
    for(int i=0;i<len;i++){cen[arr[i]]++;}
    int j=0;
    for(int i=0;i<=k;i++){
        while(cen[i]){
            arr[j++] = i;
            cen[i]--;
        }
    }
    delete []cen;
}
//
//两种随机快排
//
#include <bits/stdc++.h>
using namespace std;
int partition(int arr[],int l,int r){
    int rd = l+rand()%(r-l);
    swap(arr[l],arr[rd]);
    int key = arr[rd];
    int i=l;
    for(int j=l;j<r;j++){
        if(arr[j] < key){
            swap(arr[i],arr[j]);
            i++;
        }
    }
    swap(arr[i],arr[r]);
    return i;
}
int partition2(int arr[],int l, int r){
    int ld = l+rand()%(r-l);
    swap(arr[l],arr[ld]);
    int key = arr[l];
    while(l < r){
        while(l<r && arr[l] <= key){l++;}
        arr[r] = arr[l];
        while(l<r && arr[r] > key){r--;}
        arr[l] = arr[r];
    }
    arr[l] = key;
    return l;
}
void quicksort(int arr[],int l,int r){
    if(l < r){
        int mid = partition2(arr,l,r);
        quicksort(arr,l,mid-1);
        quicksort(arr,mid+1,r);
    }
}
//
// 基数排序
//
#include <bits/stdc++.h>
using namespace std;
void redixSort(int arr[],int len){
    int maxn = 0;
    for(int i=0;i<len;i++){maxn = max(arr[i],maxn);}
    int t = maxn;
    int d = 0;
    while(t){t/=10;d++;}
    int mod = 10;
    for(int k=0;k<d;k++){
        queue<int> Bucket[10];
        for(int i=0;i<len;i++){
            Bucket[(arr[i]%mod) / (mod/10)].push(arr[i]);
        }
        int j=0;
        for(int i=0;i<10;i++){
            while(!Bucket[i].empty()){
                arr[j++] = Bucket[i].front();
                Bucket[i].pop();
            }
        }
        mod *= 10;
    }
}
//
// 选择排序
//
#include <bits/stdc++.h>
using namespace  std;
void selectSort(int arr[],int len){
    for(int i=0;i<len-1;i++){
        int minx = i;
        for(int j=i+1;j<len;j++){
            if(arr[j] < arr[minx]){minx = j;}
        }
        swap(arr[i],arr[minx]);
    }
}
//
// 希尔排序
//
#include <bits/stdc++.h>
using namespace std;
void shellSort(int arr[],int len){
    int gap =  len/2;
    while(gap >= 1){
       //做一个直接插入
       for(int i=gap;i<len;i++){
            int j = i - gap;
            int key = arr[i];
            while(j>=0 && arr[j] > key){
                arr[j+gap] = arr[j];
                j=j-gap;
            }
            arr[j+gap] = key;
       }
       gap = gap/2;
    }
}

如果有看不懂的地方,欢迎私聊和留下评论。。。必定及时解释

相关文章
|
SQL 分布式计算 Oracle
数据同步工具DataX的安装
数据同步工具DataX的安装
6017 0
|
存储 分布式计算 运维
云栖实录|驰骋在数据洪流上:Flink+Hologres驱动零跑科技实时计算的应用与实践
零跑科技基于Flink构建一体化实时计算平台,应对智能网联汽车海量数据挑战。从车机信号实时分析到故障诊断,实现分钟级向秒级跃迁,提升性能3-5倍,降低存储成本。通过Flink+Hologres+MaxCompute技术栈,打造高效、稳定、可扩展的实时数仓,支撑100万台量产车背后的数据驱动决策,并迈向流批一体与AI融合的未来架构。
935 3
云栖实录|驰骋在数据洪流上:Flink+Hologres驱动零跑科技实时计算的应用与实践
|
5月前
|
存储 人工智能 文字识别
内网环境跑通RPA自动化:企业级私有化部署实战
政企客户因数据安全与合规要求(如等保三级、涉密保护),必须采用内网离线RPA:避免敏感数据外泄、保障业务连续性、满足审计要求。本文详解纯内网单机、内网集群、混合云三种私有化部署架构,离线授权机制、安全加固要点及典型踩坑案例,助力政务、金融、军工等行业安全落地RPA。(239字)
641 0
|
6月前
|
存储 人工智能 数据库
2026年阿里云免费云服务器领取及使用全攻略
阿里云免费试用中心面向个人开发者、学生及小微企业,提供云服务器、存储、数据库、AI等全栈产品免费体验,零成本上云!新用户认证后即可领取,手把手教程助你快速入门。
1161 1
|
7月前
|
存储 人工智能 安全
意图共鸣科技:AI记忆链的优雅降级——算力可以断,记忆不能断
《AI记忆链商业化白皮书》提出“优雅降级”方案:解耦算力与记忆,实现“算力可断、记忆不断”。记忆空间独立付费、永久保留,支持随时查看、导出与管理;算力按需购买,恢复即无缝续聊。让AI如停机保号般可靠。
496 7
|
7月前
|
人工智能 JSON API
给 Claude Code 装一块秒表:每轮 + 累计耗时自动反馈
JeecgBoot AI专题研究 一段指令装完,每轮 + 累计耗时直接打在屏幕上 痛点用 Claude Code 久了会发现一件事:它干完活不告诉你花了多久。![](https://oscimg.oschina.net/oscnet/upf5cf7ee21ab98e6e8cd5113b0b088
381 0
给 Claude Code 装一块秒表:每轮 + 累计耗时自动反馈
|
5月前
|
人工智能 缓存 JSON
AI 智能体的开发及上线
本项目开发一款专注股票财报可视化分析的AI智能体,融合规划、记忆、工具调用与大模型推理能力,可自主诊断异常、调取数据、生成图表及白话解读。采用Dify等低代码框架快速落地,集成RAG记忆、结构化输出与缓存优化,兼顾专业性、合规性与低成本。(239字)
|
5月前
|
消息中间件 人工智能 Java
“八股文”已死?2026技术校招面试官亲述:我们现在只问这三个真实项目题
本文揭示校招面试新趋势:面试官已从考察“知识记忆”转向甄别“真实工程能力”。通过三个核心项目题,聚焦候选人是否独立解决过真实问题——有数据、有工具、有复盘。背八股文难通关,唯真做项目者胜出。
|
8月前
|
Windows
如何完美地卸载流氓软件?软件卸载不掉也安装不了怎么办?
HiBit Uninstaller 是一款轻量级、便携式Windows卸载工具,支持彻底删除软件及残留文件、注册表项,并提供系统垃圾清理、右键菜单管理等优化功能,操作简单,免安装即用。(239字)
1609 6
|
SQL 存储 HIVE
鹰角基于 Flink + Paimon + Trino 构建湖仓一体化平台实践项目
本文整理自鹰角网络大数据开发工程师朱正军在Flink Forward Asia 2024上的分享,主要涵盖四个方面:鹰角数据平台架构、数据湖选型、湖仓一体建设及未来展望。文章详细介绍了鹰角如何构建基于Paimon的数据湖,解决了Hudi入湖的痛点,并通过Trino引擎和Ranger权限管理实现高效的数据查询与管控。此外,还探讨了湖仓一体平台的落地效果及未来技术发展方向,包括Trino与Paimon的集成增强、StarRocks的应用以及Paimon全面替换Hive的计划。
2325 1
鹰角基于 Flink + Paimon + Trino 构建湖仓一体化平台实践项目

热门文章

最新文章