排序算法汇总 c++

来源：互联网发布：360电话手表软件编辑：程序博客网时间：2024/06/07 02:08
#include <stdlib.h>#include <stdio.h>#include <vector>#include <iostream>using namespace std;template<typename T> void v_print( vector<T>& v){    int v1(v.size());    for(int k1(0);k1<v1;++k1)        cout<<v[k1]<<" ";    cout<<endl;}/*冒泡排序：依次比较相邻的数据，小数据放前，大数据放后。第一趟将最大数滚到最后一个位置，第二趟将次大的数滚到倒数第二个位置，...，依次将“最大数”的滚动到“最后”，共需要n-1趟。时间复杂度O(n^2)，空间复杂度为O(1)。稳定排序，元素较少时效率较高。*/template<typename T> void bubbleSort1( vector<T>& v){    int v1(v.size());    for(int k1(0);k1<v1-1;++k1){        for(int k2(0);k2<v1-1-k1;++k2){            if(v[k2+1]<v[k2])swap(v[k2+1],v[k2]);            //v_print(v);        }    }}/*冒泡排序优化：设置一个标志，如果第一次比较完没有交换，即说明已经有序，不应该进行下一次遍历，还有已经遍历出部分有序的序列后，那部分也不用进行遍历。最坏情况，反序序列，时间复杂度O(n^2)；最好情况，正序，时间复杂度O(n)。*/template<typename T> void bubbleSort2( vector<T>& v ){    int v1(v.size());    bool flag(1);    //cout<<v1<<endl;    for(int k1(0);k1<v1-1&&flag;++k1){        flag=false;        for(int k2(0);k2<v1-1-k1;++k2){            if(v[k2+1]<v[k2])swap(v[k2+1],v[k2]),flag=true;            //v_print(v);        }    }}/*选择排序：正序，第一趟遍历N个数据，找到最小的数值与第一个元素交换，第二趟遍历剩下N-1个元素，找出其中最小的数值与第二元素交换...与冒泡的查找过程一样，但是选择排序每一趟只最后交换一次，因此选择排序的效率相较于冒泡只高不低。时间复杂度O(n^2)，空间复杂度为O(1)。*/template<typename T> void selectSort( vector<T>& v){    int v1(v.size());    for(int k1(0),km(0);k1<v1-1;++k1,km=k1){        for(int k2(k1+1);k2<v1;++k2){            if(v[k2]<v[km])km=k2;        }        swap(v[km],v[k1]);        //v_print(v);    }}/*插入排序：与扑克摸牌一样。插入即表示将一个新数据插入到一个有序数组中，并保持有序。时间复杂度：最好的情况O(n)；最坏的情况O(n^2)。空间复杂度O(1)。稳定排序，元素少是效率好。*/template<typename T> void insertSort( vector<T>& v){    int v1(v.size());    for(int k1(1),k2,tem;k1<v1;++k1){        for(tem=v[k1],k2=k1;0<k2 && tem<v[k2-1];--k2){            v[k2] = v[k2-1];            //v_print(v);        }        v[k2] = tem;        //v_print(v);    }}/*希尔排序：按照不同步长对元素进行插入排序，步长逐步递减直到为1。又称为缩小增量排序。时间复杂度依赖于增量序列，平均O(nlogn),最差O(n^2)不稳定排序，空间复杂度O(1)。*/template<typename T> void shellSort( vector<T>& v){    int v1(v.size());    for(int kd(v1/2);kd;kd>>=1){        for(int k1(0);k1<kd;++k1){            for(int k2(k1+kd);k2<v1;k2+=kd){                for(int k3(k2);k1<k3;k3-=kd){                    if(v[k3]<v[k3-kd])                        swap(v[k3],v[k3-kd]);                    /*else                        v_print(v);*/                }            }        }    }}template<typename T> void shellSort1( vector<T>& v){    int t=0;    int v1(v.size());    T tem;    for(int kd=(v1/2);kd>0;kd>>=1){        for(int k1(kd),k2;k1<v1;k1+=kd){            for(k2=k1,tem=v[k1];k2>0&&tem<v[k2-kd];k2-=kd){                v[k2]=v[k2-kd];                //v_print(v);            }            v[k2]=tem;            //v_print(v);t++;        }    }    cout<<"t="<<t<<endl;}/*归并排序：先递归地将序列分为短序列，递归出口为短序列只有一个元素，然后把各个有序的短序列合并为一个有序序列。时间复杂度：O(nlogn)，稳定，适合元素较多的情况。*/template<typename T> void mergearray(vector<T>& a,int first,int mid,int last,vector<T>& temp){    int i=first,j=mid+1;    int n=mid,m=last;    int k=0;    while( i<=n && j<=m )    {        if(a[i]<a[j])            temp[k++]=a[i++];        else            temp[k++]=a[j++];    }    while(i<=n)        temp[k++]=a[i++];    while(j<=m)        temp[k++]=a[j++];    for(i=0;i<k;i++)        a[first+i] = temp[i];}template<typename T> void merge(vector<T>& a,int first,int last,vector<T>& temp){    if(first<last)    {        int mid = (first+last)/2;        merge(a,first,mid,temp);        merge(a,mid+1,last,temp);        mergearray(a,first,mid,last,temp);    }}template<typename T> void mergeSort( vector<T>& v){    int v1(v.size());    vector<T> p(v1);    merge(v,0,v1-1,p);}/*快速排序：划分交换排序，采用分治策略。先从数列末尾取一个元素作为基准元；然后将小于它的元素放在左边，不小于的放在右边；然后再对左右区间重复第二步，直至只要一个元素。时间复杂度的最好情况和平均情况一样为O(nlogn)，最坏情况下为O(n^2 )。空间复杂度为O(1)。不稳定排序。*/template<typename T> int partition( vector<T>& v,int first,int last ){    int kt(first);    for(int k1(first);k1<last;++k1){        if(v[k1]<v[last]){            swap(v[kt++],v[k1]);            //v_print(v);        }    }    swap(v[kt],v[last]);    //v_print(v);    return kt;}template<typename T> void quickSort( vector<T>& v,int first,int last){    if(first<last)    {        int pivot = partition(v,first,last);        quickSort(v,first,pivot-1);        quickSort(v,pivot+1,last);        //v_print(v);    }}template<typename T> void quickSort( vector<T>& v ){quickSort(v,0,v.size()-1);}/*堆排序：初始化堆；将当前无序去的堆顶元素通该区域最后一个元素交换，然后调整堆，即将堆顶元素“下沉”到正确的位置。时间复杂度：最好，最坏都是O(nlogn)，较多元素的时候效率比较高，空间复杂度为O(1)。不稳定排序。*/template<typename T> void minheapfixdown( vector<T>& v,int i, int n){    T temp=v[i];    int j=2*i+1;    while(j<n)    {        if( j+1<n && v[j+1]<v[j] )            j++;        if(v[j] >= temp)            break;        v[i]=v[j];        i=j;        j=i*2+1;    }    v[i] = temp;}template<typename T> void maxheapfixdown( vector<T>& v,int i, int n){    T temp=v[i];    int j=2*i+1;    while(j<n)    {        if( j+1<n && v[j+1]>v[j] )            j++;        if(v[j] <= temp)            break;        v[i]=v[j];        i=j;        j=i*2+1;    }    v[i] = temp;}template<typename T> void buildheap( vector<T>& v,int v1){    for(int k1(v1/2-1);k1>=0;k1--)maxheapfixdown(v,k1,v1);}template<typename T> void heapSort( vector<T>& v ){    int v1(v.size());    buildheap(v,v1);    for(int k1(v1-1);k1>0;--k1){        swap(v[k1],v[0]);        maxheapfixdown(v,0,k1);    }}void main(){    int num[]={2,5,6,8,4,3,9,1,0,7};    vector<int> v(num,num+10);//vs2010没办法不支持C++11/(ㄒoㄒ)/    string str[]={"a","is","the","first","word"};    vector<string> s(str,str+5);    cout<<"before:"<<endl;    v_print(v);    //bubbleSort1(v);    bubbleSort2(v);    //insertSort(v);    //selectSort(v);    //shellSort(v);    //shellSort1(v);    //mergeSort(v);    //quickSort(v);    //heapSort(v);    cout<<"after:"<<endl;    v_print(v);}
阅读全文
0 0