Exercice langage C : Chaîne et Tableau

Exercice 1:

Ecrire un programme qui lit une liste de Nb nombres, la décale d'un cran vers le haut (le premier doit se retrouver en dernier), l'affiche puis la décale vers le bas.
On pourra décomposer le programme en fonctions.

Exercice 2:

Classer automatiquement un tableau de Nb entiers puis l'afficher dans l'ordre croissant puis décroissant.
On pourra utiliser des fonctions de l'exercice précédent.
On pourra créer un (ou plusieurs) tableau temporaire (donc local).
Si vous vous en sentez la force, prévoyez le cas de valeurs égales. 

rotation
#include
typedef int composante;
void lecture(composante *t,int *nb)
{
int i;
puts("nombre de valeurs à entrer ? ");
scanf("%d",nb);
for(i=1;i<=*nb;i++)
{
printf("%dième valeur : ",i);
scanf("%d",t++);
}
}
void affiche(composante *t, int max)
{
int i;
for(i=0;i<max;i++) printf("%d ",*t++);
puts(" ");
}
void decale_bas(composante *deb, int max)
{
composante c,*t;
t=deb+(max-1);
c=*t;
while (t>deb) {*t=*(t-1);t--;}
*t=c;
}
void decale_haut(composante *t, int nb)
{
composante c;int i;
c=*t;
for (i=1;i<nb;i++) {*t=*(t+1);t++;}
*t=c;
}
void main(void)
{
composante tableau[100];
int nombre;
lecture(tableau,&nombre);
puts("tableau initial :");
affiche(tableau,nombre);
decale_haut(tableau,nombre);
puts("décalage vers le haut :");
affiche(tableau,nombre);
decale_bas(tableau,nombre);
puts("décalage vers le bas :");
affiche(tableau,nombre);
}

#include
#define dim 100
typedef int composante;
void lecture(composante *t,int *nb)
{
int i;
puts("nombre de valeurs à entrer ? ");
scanf("%d",nb);
for(i=1;i<=*nb;i++)
{
printf("%dième valeur : ",i);
scanf("%d",t++);
}
}
void affiche(composante *t, int max)
{
int i;
for(i=0;i<max;i++) printf("%d="" ",*t++);<br="">
puts(" ");
}
int indice_min(composante t[],int indice_dep, int nb_indices)
/* cherche l'indice de la valeur du tableau :
* -soit égale à t[indice_dep], mais d'indice > à indice_dep;
* -soit la plus petite mais >t[indice_deb]
*/
{
int i,indice_resultat=-1;
for(i=indice_dep+1;i<nb_indices;i++) if="" (t[i]="=t[indice_dep])" return(i);<br="">
/* si on est encore là c'est qu'il n'y en pas d'égal */
for(i=0;i<nb_indices;i++)
if ((t[i]>t[indice_dep]) && ((indice_resultat<0) || (t[i]<t[indice_resultat]))) indice_resultat="i;<br">
return(indice_resultat);
}
void copier(composante *source, composante *dest, int nb)
/* copie le tableau source dans le tableau dest */
{
int i;
for(i=0;i<nb;i++) *(dest++)="*(source++);<br">
}
void classe(composante tab[], int nb)
{
composante tempo[dim]; /* un malloc(sizeof(composante)*nb) aurait été
mieux mais on n'en a pas encore parlé en cours */
int i,ind_faits,indice;
/* 1er : recherche du plus petit, le 1er si ex aequo */
indice=0;
for(i=1;i<nb;i++)
if(tab[i]<tab[indice]) indice="i;<br">
tempo[ind_faits=0]=tab[indice];
/* les suivants : recherche le + petit mais > au précédent */
for(ind_faits=1;ind_faits<nb;ind_faits++)
{
indice=indice_min(tab,indice,nb);
tempo[ind_faits]=tab[indice];
}
copier(tempo,tab,nb);
}
void main(void)
{
composante tableau[dim];
int nombre;
lecture(tableau,&nombre);
puts("tableau initial :");
affiche(tableau,nombre);
classe(tableau,nombre);
puts("tableau classé :");
affiche(tableau,nombre);
}