#include <stdio.h>
#include <stdlib.h>

void Swap_Two(int *p1, int *p2); //交换两个整数
void Select_Sort(int A[], int N); //选择排序

//主函数，其余类似
int main()
{
    int N, i;
    int *p = NULL;
    //将N个整数存储至数组中
    scanf("%d", &N); //读入个数N
    p = (int *)malloc(sizeof(int) * N); //申请数组
    for(i=0; i<N; i++){
        scanf("%d", &p[i]);
    }
    //排序并打印
    Select_Sort(p, N);
    for(i=0; i<N; i++){
        printf("%d", p[i]);
        if(i != N-1)
            printf(" ");
    }

    free(p);
    return 0;
}

void Swap_Two(int *p1, int *p2){ //交换两个长整型数
    int temp;
    temp = *p1;
    *p1 = *p2;
    *p2 = temp;
    return;
}

void Select_Sort(int A[], int N){ //选择排序
    int i, j, min_idx;
    for(i=0; i<N-1; i++){
        min_idx = i;  //初始化最小值索引
        for(j=i+1; j<N; j++){
            if(A[j] < A[min_idx])  //若待排序列中有比当前最小值还小的，则更新最小值索引
                min_idx = j;
        }
        if(min_idx != i) //若更新过最小值索引
            Swap_Two(&A[i], &A[min_idx]);
    }
    return;
}

void Swap_Two(int *p1, int *p2){ //交换两个整数
    int temp;
    temp = *p1;
    *p1 = *p2;
    *p2 = temp;
    return;
}

void Insert_Sort(int A[], int N){ //直插排序
    int temp, i, k;
    for(i=1; i<N; i++){
        temp = A[i];
        for(k=i-1; k>=0 && temp<A[k]; k--){
            A[k+1] = A[k];
        }
        A[k+1] = temp;
    }
    return;
}

void Shell_Sort(int A[], int N){ //希尔排序
    int k, i, j, p, temp;
    int t = 0;
    int D[33]; //假定增量序列不超过2^32
    //定义Hibbard增量序列
    for(k=1; k<33; k++){
        t = 2 * t + 1; //增量序列项
        if(t < N){
            D[k] = t;
        }else{
            break;
        }
    }
    //进行k-1(增量序列的个数)趟插排
    for(p=k-1; p>=1; p--){
        for(i=D[p]; i<N; i++){
            temp = A[i];
            for(j=i-D[p]; j>=0 && temp<A[j]; j-=D[p]){
                A[j+D[p]] = A[j];
            }
            A[j+D[p]] = temp;
        }
    }

    return;
}

#define Radix 10
#define MaxDigit 4

typedef struct ENode{ //定义元素结点
    int data;
    struct ENode *next;
}*PtrToNode;
typedef struct BucketNode{ //定义桶结点结构
    PtrToNode head;
    PtrToNode tail;
}*Bucket;

void LSDRadix_Sort(int A[], int N){ //基排序
    int i, D; //D为位， d为第D位上的数字（范围为0到9）
    //定义两个大小为Radix的桶，并初始化
    Bucket B1 = malloc(Radix * sizeof(struct BucketNode));
    Bucket B2 = malloc(Radix * sizeof(struct BucketNode));
    for(i=0; i<Radix; i++){
        B1[i].head = B1[i].tail = B2[i].head = B2[i].tail = NULL;   //注意大bug：B1为桶指针，但是B1[i]为结构体
    }
    //将数组中元素按照倒数第D位数字分别挂到桶B1上
    D = 1;
    Transfer_Array_To_Bucket(A, B1, N, D);
    D++;
    //开始相互倒腾，每倒腾一趟就往前看一位
    while(D <= MaxDigit){
        if(D % 2 == 0)
            Transfer_Bucket_To_Bucket(B1, B2, D);
        else
            Transfer_Bucket_To_Bucket(B2, B1, D);
        D++;
    }
    //倒腾结束后将桶中的元素依次倒入数组A中
    if(D % 2 == 0)
        Transfer_Bucket_To_Array(B1, A, N);
    else
        Transfer_Bucket_To_Array(B2, A, N);
    //释放两个桶及其元素
    Free_Bucket(B1);
    Free_Bucket(B2);
    return;
}

void Transfer_Array_To_Bucket(int A[], Bucket B, int N, int D){ //将数组A中元素按照第D位挂到桶B中
    int i, d;
    PtrToNode temp;
    for(i=0; i<N; i++){
        d = Get_Digit(A[i], D); //获取A[i]倒数第D位数字
        temp = malloc(sizeof(struct ENode)); //创建一个新结点并初始化
        temp->data = A[i];
        temp->next = NULL;
        if(B[d].tail == NULL){ //若桶的d位置上为空
            B[d].head = B[d].tail = temp;
        }else{
            B[d].tail->next = temp;
            B[d].tail = temp;
        }
    }
    return;
}

void Transfer_Bucket_To_Array(Bucket B, int A[], int N){ //将桶B1中元素依次倒入数组A中，最多不超过N
    int k, i = 0;
    PtrToNode p;

    for(k=0; k<Radix; k++){
        p = B[k].head;
        while(p != NULL){
            if(i < N){
                A[i++] = p->data;
                p = p->next;
            }else{
                return;
            }
        }
    }
    return;
}

void Transfer_Bucket_To_Bucket(Bucket B1, Bucket B2, int D){ //依次将桶B1中元素按照第D位挂到B2中，
    int k, d;
    PtrToNode p, temp;
    //依次从B1中取下元素结点，根据D位数字挂到B2上
    for(k=0; k<Radix; k++){
        p = B1[k].head;
        while(p != NULL){
            //从B1中取该元素，并获取第D位数字
            temp = p;
            p = p->next;
            d = Get_Digit(temp->data, D); //获取该结点第D位数字
            //将该元素挂到B2上
            temp->next = NULL; //肯定作为本次转移的尾结点
            if(B2[d].head == NULL){ //若B2[d]为空位置
                B2[d].head = B2[d].tail = temp;
            }else{ //若B2[d]不为空位置，则将temp结点接到尾结点上
                B2[d].tail->next = temp;
                B2[d].tail = temp;
            }
        }
        //取完B1[k]上的所有结点后，设置其首尾结点指针为空
        B1[k].head = B1[k].tail = NULL;
    }

    return;
}

int Get_Digit(int X, int D){  //获取X倒数第D位数字
    int k, i;
    for(i=0; i<D-1; i++)
        X = X / Radix;
    k = X % Radix;
    return k;
}