#include<iostream>
#include<cstring>
#include<string>
#include<queue>
#include<map>
#include<cstdlib> 
#include<cstdio>
const int INF=0X3f3f3f3f;
using namespace std;

typedef struct
{
   int a[100];
   int len;
   void outList(){
           for(int i=1; i<=len; ++i)
               cout<<a[i]<<" ";
           cout<<endl;
   }
}list;
list L;


int smaller(int a, int b)
{
   return a>b?b:a;
}
/**********************************************************************************/
void sample_selection_sort()//简单选择排序 
{
    int i, j, k;
    for(i=1; i<=L.len; i++)
     {
         k=i;
         for(j=i+1; j<=L.len; j++)
           if(L.a[k]>L.a[j])
             k=j;
        if(k!=i)
          {
              L.a[i]^=L.a[k];
              L.a[k]^=L.a[i];
              L.a[i]^=L.a[k];
          }
     }
} 
/**********************************************************************************/
int tree[400];
void tree_choose_sort(int ld, int rd, int p)//树形选择排序，和线段树差不多 
{
   if(rd==ld)
     tree[p]=L.a[ld];
   else
     {
         int mid=(ld+rd)/2;
        tree_choose_sort(ld, mid, p<<1);
        tree_choose_sort(mid+1, rd, p<<1|1);
        tree[p]=smaller(tree[p<<1], tree[p<<1|1]);
     }
}

void update_tree(int ld, int rd, int p, int key)//树形选择排序
{
    if(rd==ld)
     {
       if(key==tree[p])
          tree[p]=INF;
     } 
    else
     {
         int mid=(ld+rd)/2;
         if(key==tree[p<<1]) 
            update_tree(ld, mid, p<<1, key);
         else
            update_tree(mid+1, rd, p<<1|1, key);
         tree[p]=smaller(tree[p<<1], tree[p<<1|1]);
     }
}
/**********************************************************************************/

typedef struct tree//树形选择排序 
{
   int d;
   struct tree *lchild;
   struct tree *rchild;
}*TREE;
void build_tree(TREE &T, int ld, int rd)//树形选择排序
{
   if(ld==rd)
    { 
       T->lchild=T->rchild=NULL;
       T->d=L.a[ld];
    }
   else
   {
          int mid=(rd+ld)/2;
          T=(TREE)malloc(sizeof(tree));
          T->lchild=(TREE)malloc(sizeof(tree));
          T->rchild=(TREE)malloc(sizeof(tree));
       build_tree(T->lchild, ld, mid);
       build_tree(T->rchild, mid+1, rd);
       T->d=smaller(T->lchild->d, T->rchild->d);
   }
}

void Update_tree(TREE &T, int key)//树形选择排序
{
   if(T)
   {
      if(!T->lchild && !T->rchild)
        {
            if(T->d==key)
              T->d=INF;
        }
      else
       {
             if(key==T->lchild->d)
               Update_tree(T->lchild, key);
             else if(key==T->rchild->d)
               Update_tree(T->rchild, key);
             T->d=smaller(T->lchild->d, T->rchild->d);
       }
   }
}
/**********************************************************************************/

void heapAdjust(int ld, int rd){//堆排序, 排序区间[ld，rd] 
    int rc = L.a[ld];
    int cur = ld;
    for(int p = ld*2; p<=rd; p=p*2){
        if(p<rd && L.a[p] > L.a[p+1]) ++p;//取左右子树的最小值
        if(rc < L.a[p]) break;//如果父节点的值比左右子树的值都小，那么已经调整好了，已经是小堆顶了
        L.a[cur] = L.a[p];//否则交换父节点和左右子树最小的子树的值，父节点的值存在rc中，所以只要将最小子树的值赋给父节点就好 
        cur = p;
    }
    L.a[cur] = rc;
}

/**********************************************************************************/

int main() {
    int i;
   scanf("%d", &L.len);
   for(i=1; i<=L.len; i++)
     scanf("%d", &L.a[i]);
   //selection_sort();//选择排序 
   
//   tree_choose_sort(1, L.len, 1);//树形选择排序 
//   
//   int n=L.len;
//   while(n--)
//    {
//       printf("%d ", tree[1]);
//       update_tree(1, L.len, 1, tree[1]);
//    }
   
//   TREE T;//树形选择排序 
//   build_tree(T, 1, L.len);
//   int n=L.len;
//   while(n--)
//    {
//       printf("%d ", T->d);
//       Update_tree(T, T->d);
//    }


    for(int i=L.len/2; i>=1; --i)//将整个区间调整成小堆顶 
        heapAdjust(i, L.len);
    
    for(int i=1; i<=L.len; ++i) {
        cout<<L.a[1]<<" "; 
        L.a[1] = L.a[L.len-i+1];//将最后一个元素赋给第一个元素 
        heapAdjust(1, L.len-i);//重新调整堆 
    }
    cout<<endl;
    return 0;
}

#include<iostream>
#include<cstring>
#include<string>
#include<queue>
#include<map>
#include<cstdlib> 
#include<cstdio>
const int INF=0X3f3f3f3f;
using namespace std;

typedef struct
{
   int a[100];
   int len;
   void outList(){
           for(int i=1; i<=len; ++i)
               cout<<a[i]<<" ";
           cout<<endl;
   }
}list;
list L;

void bubble_sort()
{
   int i, j, change=1;
   for(j=L.len; change && j>=1; j--)
     {
         change=0;
         for(i=1; i<j; i++)
           if(L.a[i]>L.a[i+1])
             {
                L.a[i]^=L.a[i+1];
               L.a[i+1]^=L.a[i];
                 L.a[i]^=L.a[i+1];
                 change=1;
             }
     }
}

int main() {
    int i;
   scanf("%d", &L.len);
   for(i=1; i<=L.len; i++)
     scanf("%d", &L.a[i]);
    bubble_sort(); 
    return 0;
}

#include<iostream>
#include<cstring>
#include<string>
#include<queue>
#include<map>
#include<cstdlib> 
#include<cstdio>
const int INF=0X3f3f3f3f;
using namespace std;

typedef struct
{
   int a[100];
   int len;
   void outList(){
           for(int i=1; i<=len; ++i)
               cout<<a[i]<<" ";
           cout<<endl;
   }
}list;
list L;

int partition(int low, int high)//将数据元素划分为左边都小于枢轴，右边元素都大于枢轴 
{
   //采用三者取中的方法选择枢轴 
   if((L.a[high]-L.a[low]) * (L.a[high]-L.a[(low+high)/2]) < 0)
            swap(L.a[low], L.a[high]);
   else if((L.a[(low+high)/2]-L.a[low]) *(L.a[(low+high)/2]-L.a[high]) < 0)
           swap(L.a[low], L.a[(low+high)/2]);
   int pivotkey=L.a[low];// 枢轴关键字
   while(low<high)
     {
         while(low<high && L.a[high]>=pivotkey)
           high--;
         L.a[low]=L.a[high];
         while(low<high && L.a[low]<=pivotkey)
           low++;
         L.a[high]=L.a[low];
     }
   L.a[low]=pivotkey; 
   return low;
} 

int partitionTwo(int ld, int rd){
　　int mid = (ld+rd)>>1;
　　if((a[mid]-a[ld]) * (a[mid]-a[rd]) < 0)
　　　　swap(a[mid], a[ld]);
　　else if((a[rd]- a[ld]) * (a[rd]-a[mid]) < 0)
　　　　swap(a[rd], a[ld]);

　　int i=ld;//使得表a[ld.....i] 中的所有的元素都是小于pivot的元素，初始表为空， a[ld]表示枢轴
　　int pivot = a[ld];
　　for(int j=ld+1; j<=rd; ++j)
　　　　if(a[j] < pivot)
　　　　　　swap(a[++i], a[j]);
　　swap(a[i], a[ld]);
　　return i;
}

void Qsort(int low, int high)//快速排序 
{
   if(low<high)
    {
       int p=partition(low, high);
       Qsort(low, p-1);
       Qsort(p+1, high);
    }
}


int main() {
   int i;
   scanf("%d", &L.len);
   for(i=1; i<=L.len; i++)
     scanf("%d", &L.a[i]);
    Qsort(1, L.len); 
    L.outList();
    return 0;
}

#include<iostream>
#include<cstring>
#include<string>
#include<queue>
#include<map>
#include<cstdlib> 
#include<cstdio>
const int INF=0X3f3f3f3f;
using namespace std;

typedef struct
{
   int a[100];
   int len;
   void outList(){
           for(int i=1; i<=len; ++i)
               cout<<a[i]<<" ";
           cout<<endl;
   }
}list;
list L;

void Merge(int lr, int rr)//归并排序 
{
   int atemp[100], mid=(lr+rr)/2;//atemp[]存放两个有序表合并后的结果
   int i, j, k;
   for(i=lr, j=mid+1, k=0; i<=mid && j<=rr; )//将两个有序表的合并代码 
     {
         if(L.a[i]<=L.a[j])
           atemp[k++]=L.a[i++];
         else
          atemp[k++]=L.a[j++];     
     }
   if(i>mid)
     for(k; j<=rr; j++)
       atemp[k++]=L.a[j];
   if(j>rr)
     for(k; i<=mid; i++)
       atemp[k++]=L.a[i]; 
   memcpy(L.a+lr, atemp, sizeof(int)*k);//将两段儿有序表合并后的结果 
}                                     //复制到原来对应的位置上 

void Msort(int ld, int rd)
{
   if(ld<rd)
     {
         int mid=(ld+rd)/2;
         Msort(ld, mid);
         Msort(mid+1, rd);
         Merge(ld, rd);//回溯法合并有序 序列 
     }
}


int main() {
   int i;
   scanf("%d", &L.len);
   for(i=1; i<=L.len; i++)
     scanf("%d", &L.a[i]);
    Msort(1, L.len); 
    L.outList();
    return 0;
}

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio> 
using namespace std;
const int INF=0X3f3f3f3f;
typedef struct
{
   int a[100];
   int len;
   void outList(){
        for(int i=1; i<=len; ++i){
            cout<<a[i]<<" ";
        }
        cout<<endl;
   }
}list;
list L;

/*********************************************************************/ 
void direct_insertion_sort()//直接插入排序 
{
   int i, j;
   for(i=2; i<=L.len; i++)
     {
         L.a[0]=L.a[i];
         for(j=i-1; L.a[0]<L.a[j]; j--)
           L.a[j+1]=L.a[j];
         L.a[j+1]=L.a[0];
     }
}

/*********************************************************************/ 

void benary_insertion_sort1()//折半插入排序 
{
   int i, j, left, right, mid;
   for(i=2; i<=L.len; i++)
     {
        left=1;
        right=i-1;
        L.a[0]=L.a[i];
        while(left<=right)
         {
               mid=(left+right)/2;
               if(L.a[mid]<=L.a[0])
                  left=mid+1;
               else
                  right=mid-1;
         }
        for(j=i-1; j>=left; j--)
          L.a[j+1]=L.a[j];
        L.a[j+1]=L.a[0];
     }
} 

/*********************************************************************/ 

void benary_insertion_sort2(){//折半插入排序 
    for(int i=2; i<=L.len; ++i){
        L.a[0] = L.a[i];
        int k = upper_bound(L.a+1, L.a+i, L.a[0]) - L.a;//返回最后一个大于key的位置 
        for(int j=i; j>k; --j)
            L.a[j] = L.a[j-1];
        L.a[k] = L.a[0];
    }
}

/*********************************************************************/ 
void twoWay_insertion_sort()//二路插入排序 
{
   int *d=(int *)malloc(sizeof(int)*L.len);
   int first, final, i, j;
   first=final=0;
   d[0]=L.a[1];
   for(i=2; i<=L.len; i++)
     {
         if(L.a[i]>=d[final])//直接添加在尾部 
           d[++final]=L.a[i];
         else if(L.a[i]<=d[first])//直接添加在头部 
           d[first=(first-1+L.len)%L.len]=L.a[i];
         else//在头部和尾部中间
          {
               for(j=final++; d[j]>=L.a[i]; j=(j-1+L.len)%L.len)
                 d[(j+1)%L.len]=d[j];
               d[(j+1)%L.len]=L.a[i];
          }
     }
    for(i=first, j=1; i!=final; i=(i+1)%L.len, j++)
      L.a[j]=d[i];
 　　L.a[j] = d[i];
}

/*********************************************************************/ 
void shell_insertion_sort(int d)
{
   int i, j;
   for(i=d+1; i<=L.len; i++)
     {
         if(L.a[i]<L.a[i-d])//需要将L.a[i]插入有序增量字表 
           {
                 L.a[0]=L.a[i];
               for(j=i-d; j>=1 && L.a[0]<=L.a[j]; j-=d)
                  L.a[j+d]=L.a[j];
               L.a[j+d]=L.a[0];
           }
     }
}

void shellsort()//希尔排序 
{
    int dk[]={5, 3, 1};//设置子序列的增量 
    for(int i=0; i<3; i++)
      shell_insertion_sort(dk[i]);
}

/*********************************************************************/ 

typedef struct xxx{
    int head;//头结点 
    int a[100];
    int next[100];//记录下一个元素的位置 
    int len;
    xxx(){
        head = 1;
        memset(next, 0, sizeof(next));
    }
    void outList(){
        for(int i=1; i<=len; ++i){
            cout<<a[i]<<" ";
        }
        cout<<endl;
    }
}Listx; 

Listx Lx;

void table_insertion_sort(){//表插入排序，相当于静态链表 
    for(int i=2; i<=Lx.len; ++i){
        int pre, p;
        for(p=Lx.head; p && Lx.a[p]<Lx.a[i]; pre=p, p=Lx.next[p]);
        if(p==0){
            Lx.next[pre] = i;
        } else if(p==Lx.head){
            Lx.next[i] = Lx.head;
            Lx.head = i;
        } else {
            Lx.next[pre] = i;
            Lx.next[i] = p;
        } 
    }
    //输出
    for(int i=Lx.head; i; i = Lx.next[i]) 
        cout<<Lx.a[i]<<" ";
    cout<<endl;
}

void arrang_table() {
    int p = Lx.head, q;
    for(int i=1; i<Lx.len; ++i){
        while(p < i) p = Lx.next[p];//第i个记录在表中的位置不应该小于 i，如果小于i，说明该元素已经被交换位置了，可以通过next继续寻找 
        q = Lx.next[p];//指向下一个节点 
        if(p!=i){//第p个元素应该在第i个位置 
            swap(Lx.a[i], Lx.a[p]);
            swap(Lx.next[i], Lx.next[p]);
            Lx.next[i] = p;//该元素之前的位置 p，指向被移走的记录，使得以后可由while循环找回 
        }
        p = q;
    }
    
    for(int i=1; i<=Lx.len; ++i) 
        cout<<Lx.a[i]<<" ";
    cout<<endl;
}

/*********************************************************************/ 

int main()
{
    int i;
    scanf("%d", &Lx.len);
    for(i=1; i<=Lx.len; i++)
        scanf("%d", &Lx.a[i]);
//    benary_insertion_sort2();
//    L.outList();
    table_insertion_sort();
    arrang_table();
    return 0;
}

/*
8
49 38 6 5 97 76 13 27 49
*/

#include<iostream> 
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<queue> 
#define N 1000
using namespace std;

/*
    题目：对基数排序的练习, 它是一种很特别的方法，它不是基于比较进行排序的，而是采用多关键字排序思想，
    借助"分配" 和 "收集" 两种操作对单逻辑关键字进行排序， 分为最高位优先MSD排序和最低为优LSD先排序 
*/

int radix[]={1, 10, 100, 1000};//每个数字的位数最多是3位

int cnt[10];
int a[N], bucket[N];
int n; 
int k;//记录数字中位数最多的 

/*
（1）LSD最低位优先法实现

最低位优先法首先依据最低位关键码Kd对所有对象进行一趟排序，

再依据次低位关键码Kd-1对上一趟排序的结果再排序，

依次重复，直到依据关键码K1最后一趟排序完成，就可以得到一个有序的序列。

使用这种排序方法对每一个关键码进行排序时，不需要再分组，而是整个对象组。
*/
void LSD_radixSort(){
    for(int i=1; i<=k; ++i){
        memset(cnt, 0, sizeof(cnt));
        //统计各个桶中所盛数据个数, 关键字相同的数字放入到同一个桶中 
        for(int j=1; j<=n; ++j)
            ++cnt[a[j]%radix[i]/radix[i-1]];
        //cnt[i]表示第i个桶的右边界索引
        for(int j=1; j<10; ++j)
            cnt[j] += cnt[j-1];
         //把数据依次装入桶(注意装入时候的分配技巧)
        for(int j=n; j>=1; --j){//这里要从右向左扫描，保证排序稳定性 
            int x = a[j]%radix[i]/radix[i-1]; //求出关键码的第k位的数字， 也就是第x个桶的编号， 例如：576的第3位是5 
            bucket[cnt[x]] = a[j];//放入对应的桶中，cnt[x]是第x个桶的右边界索引 
            --cnt[x];//对应桶的装入数据索引减一  
        }
        memcpy(a, bucket, sizeof(int)*(n+1));
    }
}

/*
    （2）MSD最高位优先法实现

最高位优先法通常是一个递归的过程：

<1>先根据最高位关键码K1排序，得到若干对象组，对象组中每个对象都有相同关键码K1。

<2>再分别对每组中对象根据关键码K2进行排序，按K2值的不同，再分成若干个更小的子组，每个子组中的对象具有相同的K1和K2值。

<3>依此重复，直到对关键码Kd完成排序为止。

<4> 最后，把所有子组中的对象依次连接起来，就得到一个有序的对象序列。
*/

void MSD_radixSort(int ld, int rd, int radixI){//[ld, rd]是a数组的待排序的区间，radixI是当前这段数组每个数字的基数 
    int cnt[11];//必须每个栈中都定义 
    memset(cnt, 0, sizeof(cnt));
    //统计各个桶中所盛数据个数, 关键字相同的数字放入到同一个桶中 
    for(int j=ld; j<=rd; ++j)
        ++cnt[a[j]%radix[radixI]/radix[radixI-1]];
    //cnt[i]表示第i个桶的右边界索引
    for(int j=1; j<=10; ++j)
        cnt[j] += cnt[j-1];
     //把数据依次装入桶(注意装入时候的分配技巧)
    for(int j=rd; j>=ld; --j){//这里要从右向左扫描，保证排序稳定性 
        int x = a[j]%radix[radixI]/radix[radixI-1]; //求出关键码的第k位的数字， 也就是第x个桶的编号， 例如：576的第3位是5 
        bucket[cnt[x]] = a[j];//放入对应的桶中，cnt[x]是第x个桶的右边界索引 
        --cnt[x];//对应桶的装入数据索引减一  
    }
    for(int i=ld, j=1; i<=rd; ++i, ++j)//重排区间[ld, rd], a数组区间[ld,rd]对应bucket数组区间[1, rd-ld+1] 
        a[i] = bucket[j];
         
    for(int i=0; i<10; ++i){//对各个桶中的数据在进行下一个关键字的排序 
        int ldd = ld + cnt[i];
        int rdd = ld + cnt[i+1] - 1; //获得子桶的子区间[ldd, rdd] 
        if(ldd < rdd && radixI>1)
            MSD_radixSort(ldd, rdd, radixI-1);
    }
}

int main(){
    cin>>n;
    k = 0; 
    for(int i=1; i<=n; ++i){
        cin>>a[i];
        k = max(k, (int)log10(a[i])+1);
    }
//    LSD_radixSort();
//    for(int i=1; i<=n; ++i) 
//        cout<<a[i]<<" " ;
//    cout<<endl;

    MSD_radixSort(1, n, k);
    for(int i=1; i<=n; ++i) 
        cout<<a[i]<<" " ;
    cout<<endl;
    return 0;
}
/*
7
329 457 657 839 436 720 355
*/