桶排序

#include<iostream>
using namespace std;

struct node
{
    node *next;
    double n;
};


struct list
{
    node *head;
    int n = 0;
};

void addlist(list *t, double i)
{
    if (t->n == 0)
    {
        t->head = new node;
        t->head->n = i;
        t->head->next = NULL;
        t->n++;
    }
    else
    {
        node *x = new node;
        x->n = i;
        x->next = t->head;
        t->head = x;
        t->n++;
    }
}


void insertion(list *b)
{
    int flag = 1;
    if (b->n < 2)
        ;
    else
    {
        node *m1;
        node *m=b->head;
        node *q = b->head->next;
        node *p = b->head;
        while (flag)
        {
            if (q->next == NULL)
                flag = 0;
            double t = q->n;
            while (p->n < t)
            {
                if (p == b->head)
                {
                    m1 = b->head;
                }
                else m1 = m1->next;
                p = p->next;
                
            }
            m->next = q->next;
            if (m1 != NULL)
            m1->next = q;
            q->next = p;
            q = m->next;
        }
    }
}

void Radix_Sort(double a[], int n)
{
    list b[10];
    int j;
    for (int i = 1; i <= n; i++)
    {
        
        j = n*a[i];
        addlist(&b[j], a[i]);
    }
    for (int i = 0; i < n; i++)
    {
        insertion(&b[i]);
    }
    for (int i = 0; i < n; i++)
    {
            for (int j = 1; j <= b[i].n; j++)
            {
                cout << b[i].head->n << endl;
                b[i].head = b[i].head->next;
            }
    }
}



void main()
{
    double a[11];
    for (int i = 1; i <= 10; i++)
        a[i] = 1.0 - 0.06*i;
    Radix_Sort(a, 10);


    
    
    
}

桶排序先把要排的小数乘一个整数，按得到整数的整数部分，放入list[整数部分]。

在用成熟的排序算法把list中的小数进行排序，因为数列较少，降低了比较的次数，从而提高效率。

缺点减少了时间，但却消耗了较多的内存。