Radix-Sort in C++implementiert werden

Ich versuche mich zu verbessern, mein C++ Programm erstellen, der eine große Menge von zahlen zwischen 1 und 10^6. Die Eimer, die speichern die zahlen, die in jedem Durchlauf ein array von Knoten (wo der Knoten ist eine Struktur, die ich erstellt mit einem Wert und einem next-Knoten-Attribut).

Nach dem Sortieren der zahlen in den Eimer nach den zuletzt deutlichen Mehrwert, ich habe am Ende von einem Eimer auf den Anfang noch einen Eimer (so dass ich schnell die zahlen gespeichert werden, ohne Unterbrechung der Reihenfolge). Mein code hat keine Fehler (entweder compile-oder Laufzeit -), aber ich habe eine Wand schlagen zu wie ich dabei bin zu lösen, die restlichen 6 Iterationen (da ich weiß, dass die Reihe von zahlen).

Das problem, dass ich habe ist, dass zunächst die zahlen, die geliefert wurden, sind die radixSort-Funktion in form eines int-array. Nach der ersten iteration der Sortierung, die zahlen sind jetzt gespeichert in dem array von Strukturen. Gibt es eine Möglichkeit, dass ich könnte arbeiten meine code so, dass ich nur eine for-Schleife für den 7 Iterationen, oder muss ich in eine for-Schleife, die einmal ausgeführt, und eine weitere Schleife, die darunter laufen wird 6 mal vor Rücksendung der vollständig sortierten Liste?

#include <iostream>
#include <math.h>
using namespace std;

struct node
{
    int value;
    node *next; 
};

//The 10 buckets to store the intermediary results of every sort
node *bucket[10];
//This serves as the array of pointers to the front of every linked list
node *ptr[10];
//This serves as the array of pointer to the end of every linked list
node *end[10];
node *linkedpointer;
node *item;
node *temp;

void append(int value, int n)
{
    node *temp; 
    item=new node;
    item->value=value;
    item->next=NULL;
    end[n]=item;
    if(bucket[n]->next==NULL)
    {
        cout << "Bucket " << n << " is empty" <<endl;
        bucket[n]->next=item;
        ptr[n]=item;
    }
    else
    {
        cout << "Bucket " << n << " is not empty" <<endl;
        temp=bucket[n];
        while(temp->next!=NULL){
            temp=temp->next;
        }
        temp->next=item;
    }
}

bool isBucketEmpty(int n){
    if(bucket[n]->next!=NULL)
        return false;
    else
        return true;
}
//print the contents of all buckets in order
void printBucket(){
    temp=bucket[0]->next;
    int i=0;
    while(i<10){
        if(temp==NULL){
            i++;
            temp=bucket[i]->next;                       
        }
        else break;

    }
    linkedpointer=temp;
    while(temp!=NULL){
        cout << temp->value <<endl;
        temp=temp->next;
    }
}

void radixSort(int *list, int length){
    int i,j,k,l;
    int x;
    for(i=0;i<10;i++){
        bucket[i]=new node;
        ptr[i]=new node;
        ptr[i]->next=NULL;
        end[i]=new node;
    }
    linkedpointer=new node;

    //Perform radix sort
    for(i=0;i<1;i++){
        for(j=0;j<length;j++){          
            x=(int)(*(list+j)/pow(10,i))%10;            
            append(*(list+j),x);
            printBucket(x); 
        }//End of insertion loop
        k=0,l=1;

        //Linking loop: Link end of one linked list to the front of another
        for(j=0;j<9;j++){
            if(isBucketEmpty(k))
                k++;
            if(isBucketEmpty(l) && l!=9)
                l++;
            if(!isBucketEmpty(k) && !isBucketEmpty(l)){
                end[k]->next=ptr[l];
                k++;
                if(l!=9) l++;   
            }

        }//End of linking for loop

        cout << "Print results" <<endl;
        printBucket();

        for(j=0;j<10;j++)
            bucket[i]->next=NULL;                       
        cout << "End of iteration" <<endl;
    }//End of radix sort loop
}

int main(){
    int testcases,i,input;
    cin >> testcases;
    int list[testcases];
    int *ptr=&list[0];
    for(i=0;i<testcases;i++){
        cin>>list[i];
    }

    radixSort(ptr,testcases);
    return 0;
}