排序-基数排序

基数排序

原理
基数排序(radix sort)属于“分配式排序”(distribution sort),又称“桶子法”(bucket sort)或bin sort,顾名思义,它是透过键值的部份资讯,将要排序的元素分配至某些“桶”中,藉以达到排序的作用,基数排序法是属于稳定性的排序,其时间复杂度为O (nlog(r)m),其中r为所采取的基数,而m为堆数,在某些时候,基数排序法的效率高于其它的稳定性排序法。

//算法8.11 归并排序
#include <iostream>
using namespace std;
#define  MAXSIZE  20                                //顺序表的最大长度
typedef struct
{
    int key;
    char *otherinfo;
}RedType;

typedef struct
{
    RedType *r;
    int length;
}SqList;

void Create_Sq(SqList &L)
{
    int i,n;
    cout<<"请输入数据个数,不超过"<<MAXSIZE<<"个。"<<endl;
    cin>>n;                                         //输入个数
    cout<<"请输入待排序的数据:\n";
    while(n>MAXSIZE)
    {
        cout<<"个数超过上限,不能超过"<<MAXSIZE<<",请重新输入"<<endl;
        cin>>n;
    }
    for(i=1;i<=n;i++)
    {
        cin>>L.r[i].key;
        L.length++;
    }
}

//用算法8.10 相邻两个有序子序列的归并
void Merge(RedType R[],RedType T[],int low,int mid,int high)
{
   //将有序表R[low..mid]和R[mid+1..high]归并为有序表T[low..high]
    int i,j,k;
    i=low; j=mid+1;k=low;
    while(i<=mid&&j<=high)
    {
        //将R中记录由小到大地并入T中
        if(R[i].key<=R[j].key) T[k++]=R[i++];
        else T[k++]=R[j++];
    }
    while(i<=mid)                                   //将剩余的R[low..mid]复制到T中
        T[k++]=R[i++];
    while(j<=high)                                  //将剩余的R[j.high]复制到T中
        T[k++]=R[j++];
}//Merge 

void MSort(RedType R[],RedType T[],int low,int high)
{
    //R[low..high]归并排序后放入T[low..high]中
    int mid;
    RedType *S=new RedType[MAXSIZE];
    if(low==high) T[low]=R[low];
    else
    {
        mid=(low+high)/2;                           //将当前序列一分为二,求出分裂点mid
        MSort(R,S,low,mid);                         //对子序列R[low..mid] 递归归并排序,结果放入S[low..mid]
        MSort(R,S,mid+1,high);                      //对子序列R[mid+1..high] 递归归并排序,结果放入S[mid+1..high]
        Merge(S,T,low,mid,high);                    //将S[low..mid]和S [mid+1..high]归并到T[low..high]
    }//else
}// MSort 

void MergeSort(SqList &L)
{
    //对顺序表L做归并排序
    MSort(L.r,L.r,1,L.length);
}//MergeSort
void show(SqList L)
{
    int i;
    for(i=1;i<=L.length;i++)
        cout<<L.r[i].key<<endl;
}
void main()
{
    SqList R;
    R.r=new RedType[MAXSIZE+1];
    R.length=0;
    Create_Sq(R);
    MergeSort(R);
    cout<<"排序后的结果为:"<<endl;
    show(R);
}

原文地址:https://www.cnblogs.com/ygjzs/p/12070590.html

时间: 2024-11-09 01:02:27

排序-基数排序的相关文章

常见的排序算法(四)( 归并排序,计数排序 , 基数排序)

 归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用.将已有序的子序列合并,得到完全有序的序列:即先使每个子序列有序,再使子序列段间有序.若将两个有序表合并成一个有序表,称为二路归并. (如果读者不太了解什么叫分治法,可以去看看<算法导论>第一二章.) 归并过程为:比较a[i]和a[j]的大小,若a[i]≤a[j],则将第一个有序表中的元素a[i]复制到r[k]中,并令i和k分别加上1:否则将第

桶排序/基数排序(Radix Sort)

说基数排序之前,我们先说桶排序: 基本思想:是将阵列分到有限数量的桶子里.每个桶子再个别排序(有可能再使用别的排序算法或是以递回方式继续使用桶排序进行排序).桶排序是鸽巢排序的一种归纳结果.当要被排序的阵列内的数值是均匀分配的时候,桶排序使用线性时间(Θ(n)).但桶排序并不是 比较排序,他不受到 O(n log n) 下限的影响.          简单来说,就是把数据分组,放在一个个的桶中,然后对每个桶里面的在进行排序. 例如要对大小为[1..1000]范围内的n个整数A[1..n]排序 首

数据结构排序-基数排序

基数排序是跟前面的几种排序算法完全不一样的排序算法,前面的排序算法主要通过关键字之间的比较和移动来实现,而基数排序不需要进行关键字之间的比较,它是借助多关键字的思想来实现的.对于数字,每一位上的数字就是一个关键字,每一位的数字范围就是关键字范围,它的主要过程为:将所有待比较数值(正整数)统一为同样的数位长度,数位较短的数前面补零.然后,从最低位开始,依次进行一次排序.这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列,如下图所示.类似从低位到高位比较,就是从次关键字到主关键字比较,

排序——基数排序

五.基数排序 1.基本思想:将所有待比较数值(正整数)统一为同样的数位长度,数位较短的数前面补零.然后,从最低位开始,依次进行一次排序.这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列. 2.实例 3.java实现 复制代码 package com.sort; import java.util.ArrayList; import java.util.List; //稳定 public class 基数排序 { public static void main(String[] ar

大话桶排序 基数排序和计数排序

一:计数排序 (1)当输入的元素是 n 个 0 到 k 之间的整数时,它的运行时间是 Θ(n + k).计数排序不是比较排序,排序的速度快于任何比较排序算法.由于用来计数的数组C的长度取决于待排序数组中数据的范围(等于待排序数组的最大值与最小值的差加上1),这使得计数排序对于数据范围很大的数组,需要大量时间和内存.例如:计数排序是用来排序0到100之间的数字的最好的算法,但是它不适合按字母顺序排序人名.但是,计数排序可以用在基数排序中的算法来排序数据范围很大的数组. (2)算法的步骤如下: 1.

计数排序+基数排序

这几天一直在写排序算法,从插入,冒泡,选择到归并和快速再到计数和基数排序.今天来写下计数排序和基数排序吧. 计数排序:对于一组小于k的数组,进行排序.这里要保证输入的关键值在[0..k]之间.貌似很简单,我们先不管什么是计数排序CountSort(A,1,n),先来看一下一段代码. CountPrint(int *A,int n,int k)代码: void CountPrint(int *A,int n,int k){//输入数组A,每个元素都小于k //C[i]用来计算i出现的次数,起初C[

内部排序-&gt;基数排序-&gt;链式基数排序

文字描述 基数排序是和前面各类排序方法完全不相同,前面几篇文章介绍的排序算法的实现主要是通过关键字间的比较和移动记录这两种操作,而实现基数排序不需要进行记录关键字间的比较.基数排序是一种借助多关键字排序的思想对单逻辑关键字进行排序的方法.先介绍下什么是多关键字排序,以引入链式基数排序算法. 先介绍什么是多关键字排序: 比如,对扑克牌进行排序,每张扑克牌有两个"关键字":花色(梅花<方块<红桃<黑桃)和面值(2<3<,-,A),且"花色"

计数排序-桶排序-基数排序

计数排序 计数排序的实现主要是数据样本的特殊性(正整数,明确最大边界)和利用列表索引位置来记录值,索引值来统计个数 最后循环索引,根据值(个数)确定添加多少个 import time def cal_time(func): def wrapper(*args, **kwargs): t1 = time.time() result = func(*args, **kwargs) t2 = time.time() print("%s running time: %s secs." % (f

八大基本排序--基数排序

原数组和桶如下: 第一次按照个位排序如下 取出的时候按照从0~9的顺序,且同一个桶中,先放进去的先出来 第二次按照十位排序如下 取出结果如下 第三次次按照百位排序如下 取出结果如下: 此时数组已经有序了 代码思路: 我们排序的次数取决于数组中最大是数字的位数 import java.util.Arrays; //基数排序 public class RadixSort { public static void main(String[] args) { int[] arr = { 23, 6, 1