常用排序算法C++ && Python实现
来源：互联网 发布：linux web视频服务器 编辑：程序博客网 时间：2024/06/06 05:31
本文对常用的排序算法进行总结，并利用C++和Python语言实现。 一、直接插入排序1. 算法思想：
直接插入排序的思想是：从待排序序列的第一个元素开始，依次比较相邻的两个元素，若后者小于前者（从小到大排序），则将后者作为哨兵，插入到序列中的正确位置。
那么问题来了，怎么样才能将哨兵插入到正确的位置呢？这就是下面需要着重解决的问题。
考虑，第i个元素作为哨兵，则意味着data[i-1]>data[i]的，且经过前面的排序后，前面的0~i-1个元素已经从小到大排好序了。那么，可以从第i-1个元素开始，向序列首部方向，依次比较与哨兵的大小，若大于哨兵，则向后移动一个单位，如小于哨兵，则将哨兵插入到此元素之后。
2. C++实现（IDE: VS2012）
//打印排序结果函数void Print(int a[],int n,int i=0){ //cout<<i<<endl; cout<<"排序后的结果为:"<<endl; for(int i=0;i<n;i++) cout<<a[i]<<" "; cout<<endl;}//插入排序---直接插入排序，时间复杂度O(N^2)void ZhiJieChaRuPaiXu(int a[8],int n) //函数输入参数---数组a中存有待排序数据，n为数据个数{ for(int i=1;i<n;i++) //待排序数组长度为n { if(a[i]<a[i-1]){ int j=i-1; int x=a[i]; //复制哨兵，将参考值保存 while(x<a[j]) //判断坐标i之前的每个数值，若大于参考值 { a[j+1]=a[j]; //将值向前移动 j--; //坐标值前移 } a[j+1]=x; //若第j个数据不再小于参考值，则将参考值插入到j+1位置 } Print(a,n,i); }}3 Python实现（Python 2.7）
'''输出排序结果函数'''def Print(ddata): n=len(ddata) for i in range(n): print ddata[i], #其中"，"为了不让其输出默认的换行符'''插入排序---直接插入排序'''def ZhiJieChaRuPaiXu(data): n=len(data) for i in range(1,n): if(data[i]<data[i-1]): ShaoBing=data[i] j=i-1 while(ShaoBing<data[j]): #每次移动一个数据 data[j+1]=data[j] j=j-1 if(j==-1): #当j为-1时，表明ShaoBing为最小元素， data[0]=ShaoBing break data[j+1]=ShaoBing Print(data) 二、希尔排序（缩小增量排序）算法思想
希尔排序是在直接插入排序的基础上进行改进。直接插入排序时每次数据间间隔总为1，遍历整个序列，而希尔排序时每次数据间间隔分别为n/2、n/4、…、1，然后再对每一个分组数据进行直接插入排序，当间隔小于1时，表明排序完成。C++代码（VS2012）：
//打印排序结果函数void Print(int a[],int n,int i=0){ //cout<<i<<endl; cout<<"排序后的结果为:"<<endl; for(int i=0;i<n;i++) cout<<a[i]<<" "; cout<<endl;}//希尔排序（缩小增量排序）,不稳定排序void ShellInsertSort(int a[],int n,int dk)//函数输入参数---数组a存有待排序数据，n为数据个数，dk为间隔增量{ for(int i=dk;i<n;i++) { if(a[i]<a[i-dk]){ int j=i-dk; //存坐标 int x=a[i]; //哨兵，存参考值 a[i]=a[i-dk]; //首先后移一个元素 while(x<a[j]){ a[j+dk]=a[j]; j-=dk; } a[j+dk]=x; } Print(a,n,i); }}void ShellSort(int a[],int n){ int dk=n/2; while(dk>=1) { ShellInsertSort(a,n,dk); dk=dk/2; }}3 Python代码（Python 2.7）
'''输出排序结果函数'''def Print(ddata): n=len(ddata) for i in range(n): print ddata[i], #其中"，"为了不让其输出默认的换行符'''插入排序---希尔排序'''def ShellInsertSort(data,dk,n): for i in range(dk,n): if(data[i-dk]>data[i]): j=i-dk ShaoBing=data[i] while(ShaoBing<data[j]): data[j+dk]=data[j] if(j<0 and (data[j]==data[j+dk])): #由于Python列表有负索引，此处为了避免索引值 break j-=dk data[j+dk]=ShaoBing return datadef ShellSort(data): n=len(data) dk=n/2 while(dk>=1): ShellInsertSort(data,dk,n) dk=dk/2 Print(data) 三、选择排序1. 算法思想：
选择排序有简单的选择排序和二元选择排序。其中，简单选择排序是依次寻找序列中的最小值，然后将其放入序列的前端。比如，序列 a[16]={88,10,71,29,50,9,34,4,675,3,89,19,55,67,45,234};第一次循环找到最小值3，然后与第一个元素交换；接下来，在除去第一个元素后的序列中寻找最小值，并与原序列中的第二个元素交换；直到第n个元素与第n-1个元素交换完成，则排序结束。而二元选择排序则是每次循环确定最大值和最小值，将最大值向序列尾部放，将最小值向序列首部放，这样循环n/2次就足够。
2. C++程序（VS2012）
//打印排序结果函数void Print(int a[],int n,int i=0){ //cout<<i<<endl; cout<<"排序后的结果为:"<<endl; for(int i=0;i<n;i++) cout<<a[i]<<" "; cout<<endl;}简单选择排序：
//简单选择排序---每次循环确定一个元素int FindMin(int a[],int n) //查找数组中最小值 { int minA=a[0]; for(int i=1;i<n;i++) { if(a[i]<=minA){ minA=a[i]; } } return minA; }int minIndex(int a[],int n,int minA) //确定最小值出现位置{ int Index; for(int i=0;i<n;i++) { if(a[i]==minA) { Index=i; break; } } return Index; }void SimpleSelectSort(int a[],int b[],int n){ int index; for(int i=0;i<n;i++) { b[i]=FindMin(a,n); index=minIndex(a,n,b[i]); a[index]=100000; } Print(b,n);}二元选择排序：
//二元选择排序---每次循环确定两个元素void ErYuanSelectSort(int a[],int n){ int maxIndex; //maxIndex为数组中最大值索引值 int minIndex; //minIndex为数组中最小值索引值 int temp,i,j; //temp作为两数交换时的中间值,i、j为循环变量 for(i=0;i<n/2;i++) //作不超过n/2次循环 { minIndex=i; //将最小值索引赋为每次判断序列的首位置i, maxIndex=n-i-1; //将最大值索引赋为每次判断序列的末位置n-i-1. if(a[maxIndex]<=a[minIndex]) //因为每次判断最大值和最小值，是在[i+1,n-i-1]之间判断， { //并不包括两个端点值，所以在每次判断之前， temp=a[maxIndex]; //应首先比较两者大小，若初始设定的最大值小于最小值，则交换 a[maxIndex]=a[minIndex]; //等会会有反例证明此步骤的必要性 a[minIndex]=temp; } for(j=i;j<n-i;j++) //寻找[i+1,n-i-1]之间的最大值和最小值索引 { if(a[maxIndex]<=a[j]) maxIndex=j; if(a[minIndex]>=a[j]) minIndex=j; } //交换，即将最大值往后放，最小值往前放 temp=a[i];a[i]=a[minIndex];a[minIndex]=temp; temp=a[n-i-1];a[n-i-1]=a[maxIndex];a[maxIndex]=temp; Print(a,n); //在循环内调用数据打印函数，打印每次排序结果 } Print(a,n); //调用数据打印函数，打印排序结果}3 Python程序（Python 2.7）
'''输出排序结果函数'''def Print(ddata): n=len(ddata) for i in range(n): print ddata[i], #其中"，"为了不让其输出默认的换行符简单选择排序：
'''简单选择排序'''def findMin(data): #寻找最小值和其索引 global k n=len(data) minData=data[0] for i in range(n): if(data[i]<=minData): minData=data[i] k=i return minData,kdef simSelectSort(data): n=len(data) b=[] for i in range(n): minData,minIndex=findMin(data) b.append(data[minIndex]) data[minIndex]=inf Print(b)二元选择排序：
'''二元选择排序'''def findMax(data): n=len(data) maxData=data[0] maxIndex=0 for i in range(n): if maxData<=data[i]: maxData=data[i] maxIndex=i return maxData,maxIndexdef ErYuanSelectSort(data): n=len(data) for i in range(n/2): minIndex=i;maxIndex=n-i-1 if(data[minIndex]>data[maxIndex]): data[minIndex],data[maxIndex]=data[maxIndex],data[minIndex] for j in range(i,n-i): if data[minIndex]>=data[j]: minIndex=j if data[maxIndex]<=data[j]: maxIndex=j data[i],data[minIndex]=data[minIndex],data[i] data[n-i-1],data[maxIndex]=data[maxIndex],data[n-i-1] print ' ' Print(data) 四、快速排序1.基本的快速排序算法：
（1）算法原理：
首先从待排序数组中选取参考数据keyvalue（一般选取数组第一个或最后一个数据），根据keyvalue的大小将待排序数组分成两部分（大于keyvalue部分和小于keyvalue部分），对这两部分分别递归调用快速算法。
流程图如下：
（2）C++实现：
//打印排序结果函数void Print(int a[],int n,int i=0){ cout<<"排序后的结果为:"<<endl; for(int i=0;i<n;i++) cout<<a[i]<<" "; cout<<endl;}//交换两数函数void swap(int *a,int *b) { int c; c=*a;*a=*b;*b=c;}//返回分界元素位置函数int splitFun(int a[],int low,int high) { int keyValue=a[low]; //参考值 while(low<high) { //以keyvalue为界，将待排序数组分为两部分 while(low<high && a[high]>=keyValue){--high;} swap(&a[low],&a[high]); //大于keyvalue部分 while(low<high && a[low]<=keyValue){++low;} swap(&a[low],&a[high]); //小于keyvalue部分 } return low;} //快速排序函数void quickSort(int a[],int low,int high) { if(low<high) { int pos=splitFun(a,low,high); //获取分界点位置 quickSort(a,low,pos-1); //对小于keyvalue部分进行快速排序 quickSort(a,pos+1,high); //对大于keyvalue部分进行快速排序 } Print(a,n);}（3）Python实现：
'''输出排序结果函数'''def Print(ddata): n=len(ddata) for i in range(n): print ddata[i], #其中"，"为了不让其输出默认的换行符'''快速排序'''def splitData(data,low,high): #分割函数，将数据以keyValue为界分为两部分 keyValue=data[low] while(low<high): #大于分界值部分 while(low<high and data[high]>=keyValue): high-=1 data[low],data[high]=data[high],data[low] #小于分解值部分 while(low<high and data[low]<=keyValue): low+=1 data[low],data[high]=data[high],data[low] return data,lowdef quickSort(data,low,high): if(low<high): data,pos=splitData(data,low,high) #分割 data=quickSort(data,pos+1,high) #对大于分界值部分递归调用快速排序 data=quickSort(data,0,pos-1) #对小于分界值部分递归调用快速排序 return data2.改进的快速排序算法：
算法的改进思路为：只对子序列长度大于k（k为给定值）的子序列递归调用快速排序算法，由此获得基本的有序序列后，再进行插入排序，完成待排序数组的排序工作。
（1）C++实现：
//打印排序结果函数void Print(int a[],int n,int i=0){ //cout<<i<<endl; cout<<"排序后的结果为:"<<endl; for(int i=0;i<n;i++) cout<<a[i]<<" "; cout<<endl;}void swap(int *a,int *b) //交换两数{ int c; c=*a;*a=*b;*b=c;}int splitFun(int a[],int low,int high){ int keyValue=a[low]; //参考值 while(low<high) { //以keyvalue为界，将待排序数组分为两部分 while(low<high && a[high]>=keyValue){--high;} swap(&a[low],&a[high]); //大于keyvalue部分 while(low<high && a[low]<=keyValue){++low;} swap(&a[low],&a[high]); //小于keyvalue部分 } return low;}void quickOpt(int a[],int low,int high,int k){ if((high-low)<k) //只对长度大于k的子序列进行快速排序 { int pos=splitFun(a,low,high); quickOpt(a,low,pos-1,k); quickOpt(a,pos+1,high,k); }}void quickSortOpt(int a[],int low,int high,int k){ quickOpt(a,low,high,k); //获得初步有序的数列 //进行插入排序 int n=high; for(int i=1;i<=n;i++) { int shao=a[i]; int j=i-1; while(shao<a[j]) {a[j+1]=a[j];j=j-1;} a[j+1]=shao; } Print(a,n+1);}（2）Python实现：
'''输出排序结果函数'''def Print(ddata): n=len(ddata) for i in range(n): print ddata[i], #其中"，"为了不让其输出默认的换行符def splitData(data,low,high): #分割函数，将数据以keyValue为界分为两部分 keyValue=data[low] while(low<high): #大于分界值部分 while(low<high and data[high]>=keyValue): high-=1 data[low],data[high]=data[high],data[low] #小于分解值部分 while(low<high and data[low]<=keyValue): low+=1 data[low],data[high]=data[high],data[low] return data,lowdef quickSortOpt(data,low,high,k): if (high-low)>k: #只对长度大于k的子序列进行快速排序 data,pos=splitData(data,low,high) data=quickSortOpt(data,pos+1,high,k) data=quickSortOpt(data,0,pos-1,k) return data def quickSortOpt1(data,low,high,k): data=quickSortOpt(data,low,high,k) #获得基本有序序列 for i in range(len(data)): #插入排序 temp=data[i] j=i-1 while(j>0 and data[j]>temp): data[j+1]=data[j] j=j-1 data[j+1]=temp Print(data) 五、归并排序1. 归并排序基本思想：
首先将待排序数列两两分组，将排序好的两个序列归并到中间数组中，依次类推，直到归并完整个待排序数列。
2. C++实现：
//打印排序结果函数void Print(int a[],int n,int i=0){ //cout<<i<<endl; cout<<"排序后的结果为:"<<endl; for(int i=0;i<n;i++) cout<<a[i]<<" "; cout<<endl;}//归并排序//合并两子序列函数，其中a为待排序序列，rf为中间序列，i为第一个子序列中第一个元素下标，//m为第一个子序列最后一个元素的下标，n为第二个子序列最后一个元素的下标void Merge(int *a,int *rf,int i,int m,int n){ int k=i,j=m+1; //k为中间序列下标，初值与i相同，j为第二个子序列第一个元素的下标//对两个子序列中的元素遍历，将两个子序列中较小的元素放入中间序列rf的前面,只要遍历完一个子序列便结束 while(i<=m && j<=n) { if(a[i]<=a[j]) rf[k++]=a[i++]; else rf[k++]=a[j++]; }//将两个子序列中的剩余元素放入rf中 while(i<=m) rf[k++]=a[i++]; while(j<=n) rf[k++]=a[j++]; Print(rf,n+1); //打印中间结果}void MergeSort(int *a,int *rf,int n){ int *q=a; //将*a保存起来 int len=1; //初始子序列长度 int *temp; //数组交换中间变量 while(len<n) { int i=0; //每一趟归并时，数组第一个元素下标 int s=len; //单个子序列长度 len=2*s; //子序列总长度 while(i+len<n) { //i为第一个子序列第一个元素下标； //i+s-1为第一个子序列最后一个元素下标；i+len-1为第二个子序列最后一个元素下标 Merge(q,rf,i,i+s-1,i+len-1); //更新i值，进行下一次归并 i=i+len; } if(i+s<=n) //对于归并组数为奇数的情形，归并时会有剩余子序列，将其并入前一个归并序列中 Merge(q,rf,i,i+s-1,n-1); temp=q;q=rf;rf=temp; //交换，对rf进行归并排序 }}3.Python实现：
'''输出排序结果函数'''def Print(ddata): n=len(ddata) for i in range(n): print ddata[i], #其中"，"为了不让其输出默认的换行符'''归并排序'''def Merge(data,rf,i,m,n): j=m+1;k=i #两个待归并数组的初始下标 '''将两待归并数组中的较小元素依次赋给rf''' while(i<=m and j<=n): #两个待归并数组长度 if data[i]<=data[j]: rf[k]=int(data[i]) i+=1;k+=1 else: rf[k] =int(data[j]) j+=1;k+=1 '''将两归并数组中的剩余元素赋给rf''' while(i<=m): rf[k] = int(data[i]) i+=1;k+=1 while(j<=n): rf[k] = int(data[j]) j+=1;k+=1def MergeSort(data,n): rf=zeros(n) len=1 while(len<n): i=0 s=len len=2*s '''对两两成对的数组归并''' while(i+len<n): Merge(data,rf,i,i+s-1,i+len-1) i=i+len '''对单出的数组归并''' if(i+s<=n): Merge(data,rf,i,i+s-1,n-1) data,rf=rf,data print '排序结果为：' Print(data) 六、基数排序- 基数排序的基本思想：
我是这样理解基数的：任何多位数都是有个位、十位、百位。。。构成的，那么其中的个位、十位、百位等的数字就可称为该数据的基数。从而，我们可以依次根据基数的大小来判断数据的大小。比如：先判断数据的个位数，将它们按个位数的大小从大到小依次排列起来，然后在依次比较十位数，依次类推，直至比较完数据的所有位数。- C++实现：
//打印排序结果函数void Print(int a[],int n,int i=0){ //cout<<i<<endl; cout<<"排序后的结果为:"<<endl; for(int i=0;i<n;i++) cout<<a[i]<<" "; cout<<endl;}//基数排序int maxbit(int a[],int n) //求待排序数组中数据最大位数{ int d=0,maxValue=a[0]; for(int i=1;i<n;i++) { if(a[i]>maxValue) maxValue=a[i]; } while(maxValue>0) { maxValue/=10; d++; } return d;}void radixSort(int a[],int n){ //d为待排序数列中所有数据的最大位数 //radix为取位数参数，m为当前取的数据位数，如第一位（个位）、第二位（十位）等 int d=maxbit(a,n),radix=1,m=1; int tmp[9]; //中间数组 int count[10]; //0-9十个数字的个数 while(m<=d) { for(int i=0;i<10;i++) count[i]=0; //每次排序前将桶清零 for(int i=0;i<n;i++) { int k=(a[i]/radix)%10; count[k]++; //统计第k个桶中的数据个数 } for(int i=1;i<10;i++) count[i]=count[i-1]+count[i]; //统计在count[i]之前所有的数据个数 for(int j=n-1;j>=0;j--) { int s=(a[j]/radix)%10; tmp[count[s]-1]=a[j]; //将待排序数据放入正确位置 count[s]--; //剔除已放置位置 } for(int i=0;i<n;i++) { a[i]=tmp[i]; //对排完的数组继续排序 } radix*=10; //取下一位数据 m++; //位数加1 } Print(a,n);}3.Python实现：
'''输出排序结果函数'''def Print(ddata): n=len(ddata) for i in range(n): print ddata[i], #其中"，"为了不让其输出默认的换行符'''基数排序'''def maxRadix(data,n): #获取数据最大位数 d=0 maxValue=max(data) while(maxValue>0): maxValue=maxValue/10 d+=1 return ddef RadixSort(data,n): d=maxRadix(data,n) RadData=zeros(n) rad=1 #位标志，个位为1，十位为10。。。 i=1 #数据位数标志 while(i<=d): #循环d次 count=zeros(10) #每个桶中数据个数,每次循环开始清零 for j in range(n): k=(data[j]/rad)%10 count[k]+=1 #统计个数 for m in range(1,10): count[m]+=count[m-1] #计算相应位数据个数 for l in range(n)[::-1]: kk=(data[l]/rad)%10 RadData[count[kk]-1]=data[l] count[kk]-=1 for ii in range(n): data[ii]=int(RadData[ii]) rad*=10 i+=1 Print(data) 七、堆排序堆排序是利用“堆”的概念，将一列数进行排序。本文首先介绍“堆”的定义，说明“堆”排序的过程和解决思路，最后利用C++和Python实现算法。
堆的定义
具有n个元素的序列（k1,k2,...,kn ）,当且仅当满足：
{ki≤k2iki≤k2i+1 (小顶堆) 或{ki≥k2iki≥k2i+1 (大顶堆)
时，称之为“堆”。由堆的定义可看出，堆顶元素为最小值或最大值。堆排序过程
首先将一维数组存储的二叉树序列，通过调整其中元素的位置，使之成为一个“堆”，将其堆顶元素输出，然后调整剩下的n−1 个元素使之成为一个堆，直到剩下两个元素，则交换他们的顺序，即可得有序序列。解决思路
(1)建立初始“堆”
a.对于有n 个节点的二叉树，其最后一个节点是n/2 个节点的子树
b.从n/2 个节点开始筛选，直到第一个节点结束。筛选过程如(2)所述。
(2)筛选过程
假设原先的m 个数据已构成堆，输出堆顶元素后，还剩m−1 个元素。
a.将堆尾元素放入堆顶；
b.比较堆顶元素与其子节点，是否满足堆的条件，若不满足，则与其子节点中较大者交换；
c.向下判断左子节点，是否满足堆的条件,若不满足，则与其字节点中较大者交换；
d.判断右子节点，是否满足堆的条件，若不满足，则与其子节点中较大者交换。
e.重复a、b、c、d,直到判断结束，到达最后一个节点。C++实现
//打印排序结果函数void Print(int a[],int n,int i=0){ //cout<<i<<endl; cout<<"排序后的结果为:"<<endl; for(int i=0;i<n;i++) cout<<a[i]<<" "; cout<<endl;}//堆排序void HeapAdjust(int a[],int s,int n) //s为需要调整的堆元素位置{ int child=2*s+1; //左子节点位置 while (child<n) { if(child+1<n && a[child]<a[child+1]) { child++; } if(a[s]<a[child]) { int tem=a[s]; //储存，用于交换 a[s]=a[child]; a[child]=tem; s=child; child=2*s+1; }else{break;} } }void buildHeap(int a[],int n) //建立初始堆{ for(int i=(n-1)/2;i>=0;i--) //最后一个节点所在父节点位置为（n-1)/2 { HeapAdjust(a,i,n); }}void HeapSort(int a[],int n){ buildHeap(a,n); for(int i=n-1;i>0;i--) { int temp; temp=a[i];a[i]=a[0];a[0]=temp; HeapAdjust(a,0,i); } Print(a,n);}5.Python实现
'''输出排序结果函数'''def Print(ddata): n=len(ddata) for i in range(n): print ddata[i], #其中"，"为了不让其输出默认的换行符'''堆排序'''def heapAdjust(data,s,n): #堆调整函数，data---数据，s---为待调整节点位置，n---数据长度 child=2*s+1 while(child<n): if(child+1<n and data[child]<data[child+1]): child+=1 if(data[s]<data[child]): data[s],data[child]=data[child],data[s] s=child child=2*s+1 else: break return datadef buildHeap(data,n): #建立初始堆 for i in range(-1,(n-1)/2)[::-1]: #[::-1]实现倒序循环 data=heapAdjust(data,i,n) return datadef heapSort(data,n): data=buildHeap(data,n) for i in range(n-1)[::-1]: data[0],data[i]=data[i],data[0] data=heapAdjust(data,0,i) Print(data) 八、冒泡排序一、基本冒泡排序算法
原理：对于待排序数列，从后到前依次比较相邻两个元素，若后面的元素小于前面的元素，则交换。（从小到大排序）
C++实现
//打印排序结果函数void Print(int a[],int n,int i=0){ //cout<<i<<endl; cout<<"排序后的结果为:"<<endl; for(int i=0;i<n;i++) cout<<a[i]<<" "; cout<<endl;}//冒泡排序void bubbleSort(int a[],int n){ int temp; for(int j=1;j<n;j++) { for(int j=1;j<n;j++) { if(a[j]<a[j-1]) { temp=a[j];a[j]=a[j-1];a[j-1]=temp; } } } Print(a,n);}- Python实现
'''输出排序结果函数'''def Print(ddata): n=len(ddata) for i in range(n): print ddata[i], #其中"，"为了不让其输出默认的换行符'''冒泡排序'''def bubbleSort(data,n): for i in range(n)[::-1]: for j in range(1,n-1): if data[j]<data[j-1]: data[j],data[j-1]=data[j-1],data[j] Print(data) 二、冒泡排序改进算法1
- 原理
设置是否交换标志，若循环完某一趟没有交换任何数据，则证明已排序完成。 - C++实现
//冒泡排序改进方法1---设置变化标志，若循环完某一趟没改变任何数据，则证明排序完成void bubbleSortOpt1(int a[],int n){ for(int j=0;j<n;j++) { int change=0; for(int i=1;i<n;i++) { if(a[i]<a[i-1]) { int temp=a[i];a[i]=a[i-1];a[i-1]=temp; change++; } } cout<<change<<endl; if(change==0) break; } Print(a,n);}3.Python实现
'''冒泡排序优化方法1---加入变化标志'''def bubbleSortOpt1(data,n): for i in range(n)[::-1]: change=0 for j in range(1,n): if data[j]<data[j-1]: change+=1 data[j],data[j-1]=data[j-1],data[j] if change==0: break Print(data)三、 冒泡排序改进算法2
原理
记录每趟循环交换后的位置，下次排序时，只排到此位置即可，因为后面的数据都以排好。C++实现
//冒泡排序优化方法2---记录每趟排序完成后的位置，下次排序到此位置便结束void bubbleSortOpt2(int a[],int n){ int i=n; while(i>0) { int position=0; for(int j=1;j<i;j++) { if(a[j]<a[j-1]) { position=j; int temp=a[j];a[j]=a[j-1];a[j-1]=temp; } } i=position; } Print(a,n);}- Python实现
'''冒泡排序优化方法2---记录变化位置'''def bubbleSortOpt2(data,n): for i in range(n)[::-1]: position=0 for j in range(1,i): if data[j]<data[j-1]: position=j data[j],data[j-1]=data[j-1],data[j] i=position Print(data)阅读全文
1 0
- python实现常用排序算法
- python实现常用排序算法
- 排序算法C++&&Python实现---冒泡排序
- 排序算法C++&&Python实现---归并排序
- 排序算法C++&&Python实现---归并排序
- 常用排序算法的Python实现
- Python实现常用排序算法总结
- 常用排序算法C++ && Python实现
- 常用排序算法的Python实现
- 常用排序算法的Python实现
- 用C语言实现常用排序算法
- 常用排序算法——C实现
- 常用排序算法C语言实现
- Objective-C实现常用的排序算法
- 用C语言实现常用排序算法
- 常用排序算法实现（C++）
- 常用排序算法的C语言实现
- 插入排序算法python和c实现
- VMware-NAT连接网络
- Mysql中表的自我复制(蠕虫复制)
- Apache ab自带压力工具的使用
- 小白的坑记录
- C# Enum,Int,String的互相转换
- 常用排序算法C++ && Python实现
- 无法将网络更改为桥接状态：没有未桥接的主机网络适配器的解决
- 2017 广西邀请赛&& hdu 6191 Query on A Tree（字典树启发式合并）
- lualib.h解析（5.3.4）
- redis集群安装配置
- java 7+ 实现自动锁
- H5拖拽元素
- numpy_2(多维数组降为一维reval,flatten)
- 第八篇 CSS定位
