#include<iostream>
using namespace std;
#define MaxSize 100
/*typedef int ElemType;
typedef struct
{
	ElemType datas[MaxSize];
}Sqlists;*/
template <class T1>
class Sqlist
{
	T1 data[MaxSize];
	int length;
public:
	Sqlist(T1 a[],int n){
		for(int i=0;i<n;i++)
			data[i]=a[i];
		length=n;
	}
	void output(){
		for(int i=0;i<length;i++)
			cout<<data[i]<<" ";
		cout<<endl;
	}
	void delno(T1 x);
	void partition();
	void moveodd();
};
template<class T>
struct ListNode
{
	T data;
	ListNode* next;
};
template<class T>
class List
{
	int length;
	ListNode<T>* head;
public:
	List()
	{
		head=new ListNode<T>;
		head->next=NULL;
		length=0;
	}
	void CreateList(T a[],int n){
		ListNode<T>* tail=head,*p;
		for(int i=0;i<n;i++)
		{
			p=new ListNode<T>;
			p->data=a[i];
			tail->next=p;
			tail=p;
		}
		tail->next=NULL;
		length=n;
	}
	void output(){
		ListNode<T>* p=head->next;
		for(;p;p=p->next)
			cout<<p->data<<" ";
		cout<<endl;
	}
	void split(ListNode<T> *&L1,ListNode<T> *&L2);
	void delmaxnode();
	void sort();
};
int main()
{
	int n,a[20]={0},i;
//	int x;
//	ListNode<int>* L1,*L2;
//	ListNode<int>* p; 
	cin>>n;
	for(i=0;i<n;i++)
		cin>>a[i];
//	顺序表 
//	Sqlist<int> L(a,n);
//	cin>>x;
//	L.delno(x);
//	L.output();
//	L.partition();
//	L.moveodd();
//	L.input();
//	链表
	List<int> S;
	S.CreateList(a,n);
//	S.output();
//	S.split(L1,L2);
/*	for(p=L1->next;p;p=p->next)	//测试 
		cout<<p->data<<" ";
	cout<<endl;
	for(p=L2->next;p;p=p->next)
		cout<<p->data<<" ";
	cout<<endl;*/
//	S.delmaxnode();
	S.sort();
	S.output();
}
//假设一个线性表采用顺序表表示，设计一个算法，
//删除其中所有值等于x的元素，要求算法的时间复杂度为O(n)、
//空间复杂度为O(1)
template <class T1>
void Sqlist<T1>::delno(T1 x)
{
	int k=0,i=0;
	for(i=0;i<length;i++)
		if(data[i]!=x){
			data[k]=data[i];k++;
			}
	length=k;
}
//有一个顺序表L，设计一个尽可能高效的算法，以第一个元素为基准，
//将所有小于等于它的元素移到该基准的前面，将所有大于它的元素移到该基准的后面
template <class T1>
void Sqlist<T1>::partition()
{
	int i=0,j=length-1;
	T1 pivot=data[0];
	while(i<j)
	{
		while(i<j && data[j]>pivot)
			j--;
		data[i]=data[j];
		while(i<j && data[i]<=pivot)
			i++;
		data[j]=data[i];
	}	
	data[i]=pivot;
}
//有一个顺序表L，将所有奇数移到到偶数前面
template <class T1>
void Sqlist<T1>::moveodd()
{
	int i=-1,j=0;
	for(;j<=length-1;j++)
	{
		if(data[j]%2==1){
			i++;
			if(i!=j)
				swap(data[i],data[j]);
		}
	}
} 
//有一个带头结点的单链表L=(a1,b1,a2,b2...an,bn)，
//设计一个算法将其拆分成两个带头结点的单链表L1和L2，
//其中L1=(a1,a2,...,an),L2=(bn,bn-1,... ,b1),要求L1使用L的头结点
template<class T>
void List<T>::split(ListNode<T> *&L1,ListNode<T> *&L2)
{
	L2=new ListNode<T>;
	L2->next=NULL;
	L1=head;
	ListNode<T> *p=head->next,*q,*l1=L1;
	while(p)
	{
		l1->next=p;l1=p;	//尾插法 
		
		p=p->next;
		q=p->next;	//头插法创建L2，p->next将被改变 
		
		p->next=L2->next;L2->next=p;	//头插法逆序创建 
		
		p=q;	//p重新指向原链表结点的下一位 
	}
	l1->next=NULL;
}
//删除一个单链表L中的元素值最大的结点(假设这样的结点唯一)
template<class T>
void List<T>::delmaxnode()
{
	ListNode<T>* maxnode=head->next,*p,*maxpre=head,*pre=head;
	for(p=head->next;p;p=p->next)
	{
		if(p->data>maxnode->data)
		{
			maxnode=p;
			maxpre=pre;
		}
		pre=p;
	}
	maxpre->next=maxnode->next;
	free(maxnode);
}
//有一个带头结点的单链表L(至少有一个数据结点)，
//设计一个算法使其元素递增有序数列
template <class T>
void List<T>::sort()
{
	ListNode<T>* p=head->next->next,*pre,*q;
	head->next->next=NULL;
	
	while(p)
	{
		q=p->next;
		pre=head;
		while(pre->next!=NULL && pre->next->data<p->data)
			pre=pre->next;
		p->next=pre->next;
		pre->next=p;
		p=q;
	}
}