排序算法2-希尔排序&快速排序&合并排序&基数排序&堆积树排序

 排序算法2-希尔排序&快速排序&合并排序&基数排序&堆积树排序，完整代码请点击下载 

1、希尔排序

void shellSort(int data[],int size)
{
    int i;        // i为扫描次数
    int j;        // 以j来定位比较的元素
    int k=1;      // k打印计数
    int tmp;      // tmp用来暂存数据
    int jmp;      // 设置间距位移量
    jmp = size / 2;
    while (jmp != 0)
    {
        for (i = jmp; i < size; i++)
        {
            tmp = data[i];
            j = i - jmp;
            while(tmp < data[j] && j >= 0)  //插入排序法
            {
                data[j + jmp] = data[j];
                j = j - jmp;
            }
            data[jmp + j] = tmp;
        }
        cout<<"第 "<<k++<<" 次排序：\t";
        printData(data);
        jmp = jmp / 2;    //控制循环数
    }
}

2、快速排序

void quickSort(int d[],int size,int lf,int rg)
{
    int tmp;
    int lf_idx;
    int rg_idx;
    
    if(lf<rg)   //1：第一个键值为d[lf]
    {
        lf_idx=lf+1;
        rg_idx=rg;
        
        while(1) {
            cout<<"[处理过程"<<process++<<"]=> ";
            
            for(int t=0;t<size;t++)
                cout<<"["<<setw(2)<<d[t]<<"] ";
            cout<<endl;
            
            for(int i=lf+1;i<=rg;i++)  //2：从左向右找出一个键值大于d[lf]者
            {
                if(d[i]>=d[lf])
                {
                    lf_idx=i;
                    break;
                }
                lf_idx++;
            }
            
            for(int j=rg;j>=lf+1;j--)  //3：从右向左找出一个键值小于d[lf]者
            {
                if(d[j]<=d[lf])
                {
                    rg_idx=j;
                    break;
                }
                rg_idx--;
            }
            
            if(lf_idx<rg_idx)  //4-1：若lf_idx<rg_idx
            {
                tmp = d[lf_idx];
                d[lf_idx] = d[rg_idx];
                //则d[lf_idx]和d[rg_idx]互换
                d[rg_idx] = tmp;    // 然后继续排序 
            } else {
                break;    // 否则跳出排序过程 
            }
        }
        
        if(lf_idx>=rg_idx)  //5-1：若lf_idx大于等于rg_idx
        {// 则将d[lf]和d[rg_idx]互换
            tmp = d[lf];
            d[lf] = d[rg_idx];
            d[rg_idx] = tmp;

            //5-2：并以rg_idx为基准点分成左右两半
            quickSort(d,size,lf,rg_idx-1);
            
            //以递归方式分别为左右两半进行排序
            quickSort(d,size,rg_idx+1,rg);
            //直至完成排序
        }
    }
}

3、合并排序

void quickSort(int d[],int size,int lf,int rg)
{
    int tmp;
    int lf_idx;
    int rg_idx;

    //1：第一个键值为d[lf]
    if(lf<rg)
    {
        lf_idx=lf+1;
        rg_idx=rg;
        while(1) {
            for(int i=lf+1;i<=rg;i++)
            //2：从左向右找出一个键值大于d[lf]者
            {
                if(d[i]>=d[lf])
                {
                    lf_idx=i;
                    break;
                }
                lf_idx++;
            }
            for(int j=rg;j>=lf+1;j--)
            //3：从右向左找出一个键值小于d[lf]者
            {
                if(d[j]<=d[lf])
                {
                    rg_idx=j;
                    break;
                }
                rg_idx--;
            }
            if(lf_idx<rg_idx)
            //4-1：若lf_idx<rg_idx
            {
                tmp = d[lf_idx];
                d[lf_idx] = d[rg_idx];
                // 则d[lf_idx]和d[rg_idx]互换
                d[rg_idx] = tmp;      // 然后继续排序
            } else {
                break;    // 否则跳出排序过程
            }
        }
        if(lf_idx>=rg_idx)
        //5-1：若lf_idx大于等于rg_idx
        {   // 则将d[lf]和d[rg_idx]互换
            tmp = d[lf];
            d[lf] = d[rg_idx];
            d[rg_idx] = tmp;

            //5-2：并以rg_idx为基准点分成左右两半
            quickSort(d,size,lf,rg_idx-1);
            
            //以递归方式分别对左右两半进行排序
            quickSort(d,size,rg_idx+1,rg);
            //直至完成排序
        }
    }
}

void mergeSort(int list1[], int M, int list2[], int N, int list3[])
{
    int i = 0, j = 0, k = 0;
    
    while(i < M && j < N)
    {
        if(list1[i] <= list2[j])
            list3[k++] = list1[i++];
        else
            list3[k++] = list2[j++];
    }

    while(i < M)
        list3[k++] = list1[i++];
        
    while(j < N)
        list3[k++] = list2[j++];
}

4、基数排序

void radixSort(int data[],int size)
{
    for (int n=1;n<=100;n=n*10)    	// n为基数，从个位数开始排序
    {
        int tmp[10][100]={0};      	// 设置暂存数组，[0~9位数][数据个数]，所有内容均为0
        for (int i=0;i<size;i++) 	// 对比所有数据
        {
            int m=(data[i]/n)%10;  	// m为n位数的值，例如37取十位数(37/10)%10=3
            tmp[m][i]=data[i];      // 把data[i]的值暂存在tmp中
        }
        
        int k=0;
        for (int i=0;i<10;i++)
        {
            for(int j=0;j<size;j++)
            {
                if(tmp[i][j] != 0)  // 因一开始设置 tmp = {0}，故不为0者即为
                {
                    data[k]=tmp[i][j];// data暂存在tmp中的值，把tmp中的值放回data[]中
                    k++; 
                }
            }
        }
        
        cout<<"经过"<<setw(5)<<n<<"位数排序后：";
        printData(data,size);
    }
}

5、堆积树排序

void heapSort(int *data,int size)
{
    int i,j,tmp;
    
    for(i=(size/2);i>0;i--)
        // 建立堆积树节点
        ad_heap(data,i,size-1);
        
    cout<<"\n堆积内容：";
    for(i=1;i<size;i++)
        // 原始堆积树的内容
        cout<<setw(5)<<data[i];
    cout<<endl;
    
    for(i=size-2;i>0;i--)
    // 堆积排序
    {
        tmp=data[i+1];
        // 头尾节点交换
        data[i+1]=data[1];
        data[1]=tmp;
        ad_heap(data,1,i);
        
        // 处理剩余节点
        cout<<"\n处理过程：";
        for(j=1;j<size;j++)
            cout<<setw(5)<<data[j];
    }
}
void ad_heap(int *data,int i,int size)
{
    int j,tmp,post;
    j=2*i;
    tmp=data[i];
    post=0;
    
    while(j<=size && post==0)
    {
        if(j<size)
        {
            if(data[j]<data[j+1])
            // 找出最大节点
                j++;
        }
        if(tmp>=data[j])
            // 若树根较大，结束比较过程
            post=1;
        else
        {
            data[j/2]=data[j];
            // 若树根较小，则继续比较
            j=2*j;
        }
    }
    data[j/2]=tmp;
    // 指定树根为父节点
}

完整代码请点击下载