C :

#include<stdio.h>
#include<stdlib.h>
#define ElemType int
typedef struct LNode{
	ElemType data;
	struct LNode *next;
}LNode,*LinkList;
void initial(LinkList L){
	int n;
	ElemType data;
	LNode *p = L;
	scanf("%d",&n);
	for(int i=0;i<n;i++){
		scanf("%d",&data);
		LNode *s = (LNode *)malloc(sizeof(LNode));
		s->data = data;
		p->next = s;
		p = p->next;
	}
	p->next = NULL;
}
void insert(LinkList L,ElemType elem){
	LNode *p = L;
	while(p->next){
		if(p->next->data>=elem){
			LNode *s = (LNode *)malloc(sizeof(LNode));
			s->data = elem;
			s->next = p->next;
			p->next = s;
			return;
		}
		p = p->next;
	}
	LNode *s = (LNode *)malloc(sizeof(LNode));
	s->data = elem;
	s->next = p->next;
	p->next = s;
}

void print(LinkList L){
int i=0;
	LNode *p;
	p = L->next;
	while(p){
if(i++)
printf(" ");
		printf("%d",p->data);
		p = p->next;
	}
}
int main(){
	LinkList L = (LNode *)malloc(sizeof(LNode));
	ElemType data;
	initial(L);
	scanf("%d",&data);
	insert(L,data);
	print(L);
	return 0;
}

C++ :

#include<iostream>

using namespace std;

struct Node
{
	int data;
	Node* pNext;
};

struct LinkList
{
	Node* pHead;
	Node* pTail;
};

void createList(LinkList *list)
{
	list->pHead=(Node*)malloc(sizeof(Node));
	list->pTail=list->pHead;
	list->pTail->pNext=NULL;
	
	int n;
	cin>>n;
	while(n--)
	{
		int val;
		cin>>val;
		Node* pNewNode;
		pNewNode=(Node*)malloc(sizeof(Node));
		pNewNode->data=val;
		list->pTail->pNext=pNewNode;
		pNewNode->pNext=NULL;
		list->pTail=pNewNode;
	}
}

void traverseList(LinkList *list)
{
	Node* p=list->pHead->pNext;
	for(;p!=NULL;p=p->pNext)
		cout<<p->data<<" ";
	cout<<endl;
}

int main()
{
	LinkList theList;
	createList(&theList);
	
	int val;
	cin>>val;
	
	for(Node* p=theList.pHead->pNext;p!=NULL;p=p->pNext)
	{
		if(val==(p->data))
		{
			Node* q;
			q=(Node*)malloc(sizeof(Node));
			q->data=val;
			q->pNext=p->pNext;
			p->pNext=q;
			break;
		}
	}
	
	Node* p=theList.pHead->pNext;
	for(;(p->pNext)!=NULL;p=p->pNext)
	{
		if(p->data<val&&(p->pNext->data)>val)
		{
			Node* q;
			q=(Node*)malloc(sizeof(Node));
			q->data=val;
			q->pNext=p->pNext;
			p->pNext=q;
			break;
		}
	}
	
	if(val<(theList.pHead->pNext->data))
	{
		Node* q;
		q=(Node*)malloc(sizeof(Node));
		q->data=val;
		q->pNext=theList.pHead->pNext;
		theList.pHead->pNext=q;
	}
	
	if(val>(theList.pTail->data))
	{
	
		Node* q;
		q=(Node*)malloc(sizeof(Node));
		q->data=val;
		theList.pTail->pNext=q;
		q->pNext=NULL;
		theList.pTail=q;

	}

	

	traverseList(&theList);
	//system("pause");
}