各种排序算法的代码

// ALLKindsOfSorts.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<iostream>
#include<vector>
#include<bitset>

using namespace std;

////////////////////////////////////////所有的排序总结////////////////////////////////////

//1、冒泡排序(O(n*n))
 void MaopaoSort(int *a,int len)
 {
     //这里要明白
    for(int i=0;i<len-1;i++)////这层循环控制的是需要排序的数的个数，即控制扫面的轮数
    {
        bool  IsChange=false;//这是冒泡改进的地方，增加一个标志来判断是否已经提前排好序了
        //这里要注意由于比较的是在一个循环下前一个数跟后一个数比较
        for(int j=0;j<len-i-1;j++)//这层循环是控制每一轮扫描之后，将最大的数放在最右边
        {//这里的j<len-i-1要注意边界的原因，所以是j<len-i-1
            if(a[j]>a[j+1])//相邻元素比较
            {
                //交换
                int temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
                IsChange=true;//如果一次扫描完之后都没发生任何的交换，则表明已经排好序了
            }
        }
        if(!IsChange)
        {
            cout<<"提前结束排序"<<endl;
            return;
        }
    }
 }

 //2、插入排序(O(n*n))
void InsertSort(int *a,const int len)
 {

    for(int i=1;i<len;i++)//扫描无序的数组
    {
        //记住：将第一个数作为已排序的数，从第二个数开始所有的数作为无序的数
        if(a[i-1]>a[i])//跟已排序好的数进行比较，找出合适的位置
        {        
            int temp= a[i];//将需要插入的无序数保存起来，并将所有都大于该需要插入的无序数的数后移
            int j=i-1;
            while(j>=0&&a[j]>temp)//从后往前扫描（j>=0是边界条件），判断已排序的数是否大于需要插入的无序数
            {
                a[j+1]=a[j];//如果不是合适的位置就往后移动，腾出位置出来
                j--;
            }
            a[j+1]=temp;//找到了合适的位置，执行插入
        }
    }

 }

//3、归并排序O(nlog(n))

struct Node{int v;Node* next}

Node* merge_sort(Node* p){
    if(p==NULL||p->next==NULL){
        return NULL;	
    }
    Node* head1=p;
    Node* mid=getmid(p);

    Node* head2=mid->next;
    mid->next=NULL;

    head1=merge_sort(head1);
    head2=merge_sort(head2);

    return merge(head1,head2)

}


Node* getmid(Node* p){
    if(p==NULL||p->next==NULL){
    return NULL;	
    }
    Node* fast=p;
    Node* slow=p;
    while(fast->next!=NULL){
        fast=fast->next;
        if(fast->next!=NULL){
        fast=fast->next;
        slow=slow->next;
        }
    }
    return slow

}

Node* merge(Node* p1,Node* p2){
    if(p1==NULL) return p2;
    if(p2=NULL) return p1;

    Node* head1=p1;
    Node* head2=p2;
    Node* newhead=NULL;

    if(head1->val<=head2->val){
        newhead=head1;
        head1=head1->next;
    }else{
        newhead=head2;
        head2=head2->next;
    }

    Node* ptemp=newhead;
    while(head1&&head2){
        if(head1->val<=head2->val){
        ptemp->next=head1;
        ptemp=head1;
        head1=head1->next;
        }else{
        ptemp->next=head2;
        ptemp->head2;
        head2=head2->next;
        }
    }

    ptemp->next=head1?head1:head2;
    return newhead;
}

                

　　

//4、桶排序O(n)
 //桶排序用到插入排序(O(n*n))
void InsertSort(vector<int>&a,const int len)
 {

    for(int i=1;i<len;i++)//扫描无序的数组
    {
        //记住：将第一个数作为已排序的数，从第二个数开始所有的数作为无序的数
        if(a[i-1]>a[i])//跟已排序好的数进行比较，找出合适的位置
        {        
            int temp= a[i];//将需要插入的无序数保存起来，并将所有都大于该需要插入的无序数的数后移
            int j=i-1;
            while(j>=0&&a[j]>temp)//从后往前扫描（j>=0是边界条件），判断已排序的数是否大于需要插入的无序数
            {
                a[j+1]=a[j];//如果不是合适的位置就往后移动，腾出位置出来
                j--;
            }
            a[j+1]=temp;//找到了合适的位置，执行插入
        }
    }

 }

//由于桶排序需要将数据分成n等份的范围，每个范围的个数不一样，因此每个桶里面装的数的个数不相同，
//因此选用容器作为桶的数据结构
void BucketSort(vector<int> &result,int *Data,int len)
{
    if(Data==NULL||len<=0)
        return ;
    //求原始数据的最大值与最小值
    int max_value=Data[0];
    int min_value=Data[0];
    for (int i=0;i<len;i++)
    {
        if(Data[i]>max_value)
            max_value=Data[i];
        if(Data[i]<min_value)
            min_value=Data[i];
    }
    //将数据分成n等份范围的桶
    int k=(max_value-min_value+1)/10+1;//10个桶范围
    vector<int > Bucket[10];
    //将数据分别装入相应的桶中
    for (int i=0;i<len;i++)
    {
        for(int j=0;j<10;j++)
        {
            if(Data[i]<min_value+(j+1)*k)
            {
                Bucket[j].push_back(Data[i]);
                break;//将某数放进桶内后进行下一个数
            }
        }
    }
    //分别对每一个桶内部进行排序，选用的方法是插入排序
    for (int i=0;i<10;i++)
    {
        InsertSort(Bucket[i],Bucket[i].size());
    }
    //依次输出每一个桶中的元素
    for(int i=0;i<10;i++)
    {
        for (vector<int>::size_type it=0;it<Bucket[i].size();it++)
        {
            result.push_back(Bucket[i][it]);
            //cout<<Bucket[i][it]<<" ";
        }
    }

}

//5、基数排序 O(max) max是最大值的位数
int GetPos(int a,int pos)
{
    int temp=1;
    for (int i=1;i<pos;i++)
        temp*=10;
    return (a/temp)%10;
}


void RadixSort(int *a,int len,int pos)
{
    if(a==NULL||len<=0)
        return ;
    vector<int> temp[10];//10表示十进制

    //将数据放入桶中
    for (int i=0;i<len;i++)
    {
        //a[i]%10表示的是0-9的数
        temp[GetPos(a[i],pos)].push_back(a[i]);
    }

    //按桶的顺序输出数据
    for(int i=0;i<10;i++)
    {
        for (vector<int>::size_type it=0;it<temp[i].size();it++)
        {
            *(a++)=temp[i][it];
        }
    }
}

void RadisSort( int *a,int len)
{
    if(a==NULL||len<=0)
        return ;
    int max=a[0];
    for(int i=0;i<len;i++)//求出最大值，就可以知道需要排序的次数，即排序的次数等于最大值的位数
    {
        if(a[i]>max)
            max=a[i];
    }
    int pos=1;//用来指定按哪一位来排序，最初是右边第一位
    do
    {
        //RadixSort(a,len,pos);//也可以采用函数调用的方式，避免调整指针的指向，因为在调用函数时，指针进行了复制，原始指针并没有改变

        vector<int> temp[10];//10表示十进制

        //将数据放入桶中
        for (int i=0;i<len;i++)
        {
            //a[i]%10表示的是0-9的数
            temp[GetPos(a[i],pos)].push_back(a[i]);
        }

        //按桶的顺序输出数据
        for(int i=0;i<10;i++)
        {
            for (vector<int>::size_type it=0;it<temp[i].size();it++)
            {
                *(a++)=temp[i][it];//这里要注意修改了指针本身的值
            }
        }
        //因此这里要重新调整指针指向第一个元素
        for(int i=0;i<len;i++)//求出最大值，就可以知道需要排序的次数，即排序的次数等于最大值的位数
        {
            a--;
        }

        pos++;
    }
    while(max=max/10);

}



//////////////以下是不稳定的排序//////////////////////////////////
//6、选择排序O(n*n)
void swap(int &a,int&b)
{
    int temp;
    temp=a;
    a=b;
    b=temp;
}
void SelectSort(int *a,int len)
{
    if(a==NULL||len<=0)
        return ;
    for (int i=0;i<len;i++)//需要选择n次
    {
        //a[i]每次选择的临时选择的最小值
        //将临时最小值跟后面的数进行比较，判断是否是真的最小值
        for(int j=i;j<len;j++)
        {
            if(a[j]<a[i])//如果发现比最小值还小的元素则进行交换
                swap(a[i],a[j]);
        }
    }
}

//7、希尔排序 O(n*n)

void ShellSort(int *a,int len)
{
    if(a==NULL||len<=0)
        return ;
    for (int i=len/2-1;i>=1;i--)//控制增量的循环
    {
        for (int j=i;j<len;j=j+i)//控制需要插入元素的个数
        {
            int temp=a[j];//待插入的元素
            int k=j-i;
            if(a[k]>temp)
            {
                while(k>=0&&a[k]>temp)//查找合适的位置
                {
                    a[k+i]=a[k];//按照增量的方式，将大的数按照增量的大小往后移增量个位置
                    k=k-i;//按照增量的方式递减
                }
                //找到合适的位置后，执行插入操作
                a[k+i]=temp;
            }
        }
    }
}

//8、快速排序

void QuickSort(int *a,int left,int right)
{
    if(a==NULL||left<0||right<0)
        return ;
    int i=left,j=right;
    if(left<right)
    {
        //每次都是取第一个数来作为基准，并把它拿出来，腾出一个空位用作排序
        int temp=a[i];//这里可以改进：就是选取中值或平均值作为基准，只需将它们跟第一个数进行交换位置即可，在按照相同的办法进行
        while(i<j)//当i=j时，表明一次排序已经结束，此时对应的i的位置就是
        {
            //由于开始状态是第一个位置作为第一个空位子
            //从右向左找出比基准小的数
            while(i<j&&a[j]>=temp)//若退出循环就是找到了比基准小的数
            {
                j--;
            }
            if(i<j)
            {
                a[i]=a[j];//发现右边存在比基准小的数，则将右边的数放到左边来，留下一个位置
            }
            //由于a[j]是右边留下的一个位置，因此可以从左边找出一个比基准大的数来填
            //从左向右找出比基准大的数
            while(i<j&&a[i]<=temp)//若退出循环就是找到了比基准大的数
            {
                i++;
            }
            if(i<j)
            {
                a[j]=a[i];
            }
        }
        //此时i表示原来第一个元素应该放置的正确的位置
        a[i]=temp;//将原来假设第一个位置放到他正确的位置上
        ////一次排序结束，即已经将基准值放到正确的位置上了，下面是递归排序左右两边的序列
        QuickSort(a,left,i-1);
        QuickSort(a,i+1,right);
    }
}

//9、堆排序
//通过比较二叉树父节点和左右节点的大小来调整
void HeapAdjust(int *a,int i,int size)  //调整堆 i>=1,size是序列长度
{
    int lchild=2*i;       //i的左孩子节点序号 
    int rchild=2*i+1;     //i的右孩子节点序号 
    int max=i;            //父节点 
    if(i<=size/2)          //如果i是叶节点就不用进行调整 
    {
        //判断父节点和左右之节点的大小，找出最大值
        if(lchild<=size&&a[lchild]>a[max])
        {
            max=lchild;
        }    
        if(rchild<=size&&a[rchild]>a[max])
        {
            max=rchild;
        }
        //如果最大值不是父节点
        if(max!=i)
        {
            swap(a[i],a[max]);//则进行交换
            //继续比较，直到所有的父节点都比较完为止
            HeapAdjust(a,max,size);//由于max的值没变，因此最大值就是根节点  
        }
    }        
}

void BuildHeap(int *a,int size)    //建立堆 
{
    //由于需要确保最后根节点是最大值，因此是从下往上开始建堆
    for(int i=size/2;i>=1;i--)    //非叶节点最大序号值为size/2 
    {
        HeapAdjust(a,i,size);
        for(int i=1;i<=10;i++)
            cout<<a[i]<<" ";
        cout<<endl;
    }    
} 

void HeapSort(int *a,int size)    //堆排序 
{
    BuildHeap(a,size);//首先建堆
    //再排序
    for(int i=size;i>=1;i--)
    {//每次将最大值放入最后一个位置中，对剩下的进行调整
        swap(a[1],a[i]);//交换堆顶和最后一个元素，即每次将剩余元素中的最大者放到最后面 
        HeapAdjust(a,1,i-1);//重新调整堆顶节点成为大顶堆
    }
} 



int _tmain(int argc, _TCHAR* argv[])
{
    //int a[10]={0,11,21,31,41,56,6,7,8,9};
    //int b[5]={1,2,3,4,5};
    //cout<<"排序之前的值："<<endl;
    //for (int i=0;i<10;i++)
    //    cout<<a[i]<<" ";
    //cout<<endl;
    //vector<int> c;
    //MeageSort(c,a,10,b,5);

    //BucketSort(c,a,10);
    //RadisSort( a,10);

    //cout<<"排序之后的值："<<endl;
    //for (int i=0;i<10;i++)
    //    cout<<a[i]<<" ";
    //cout<<endl;
    /*
    float a=1.0f;
    cout<<sizeof(a)<<endl;
    cout<<(int)a<<endl;
    cout<<&a<<endl;
    cout<<(int &)a<<endl;
    cout<<boolalpha<<((int)a==(int&)a)<<endl;
    
    float b=0.0f;
    cout<<sizeof(b)<<endl;
    cout<<(int)b<<endl;
    cout<<&b<<endl;
    cout<<(int &)b<<endl;
    cout<<boolalpha<<((int)b==(int&)b)<<endl;
    
    int a[10]={0,11,21,31,41,56,6,7,8,9};
    for (int i=0;i<10;i++)
        cout<<a[i]<<" ";
    cout<<endl;
    QuickSort(a,0,9);
    for (int i=0;i<10;i++)
        cout<<a[i]<<" ";
         //int a[]={0,16,20,3,11,17,8};*/
    //这里需要注意，对排序是从a[1]开始排序，因此，待排序的数要从a[1]开始
    int a[11]={0,11,21,31,41,56,6,7,8,9,10};
    HeapSort(a,10);
    for(int i=1;i<=10;i++)
        cout<<a[i]<<" ";
    cout<<endl;
  
    return 0;
}