Fonction qsort intégrée en C

#include<stdio.h>
#include<stdlib.h>
int comparaison(const void *elem1, const void *elem2) // Fonction de comparaison
{
    return *(int*)elem1 - *(int*)elem2;
}
int main()
{
    int donnees[10] = {2,4,1,5,5,3,7,4,1,5}; // Tableau non trié
    int i;
    qsort(donnees,10,sizeof(int),comparaison); // Appel de qsort pour trier
    return 0;
}

Pour un tri croissant, utilisez b-a pour un tri décroissant.

Fonction memset

# include <stdio.h>
# include <string.h>
int main(void)
{
    int i;  // Variable de boucle
    char chaine[10];
    char *pointeur = chaine;
    memset(chaine, 0, sizeof(chaine));  // Utilisez sizeof(chaine), pas sizeof(pointeur)
    for (i=0; i<10; ++i)
    {
        printf("%d\x20", chaine[i]);
    }
    printf("\n");
    return 0;
}

16 novembre

Plusieurs sauts de ligne en fin de sortie n'affectent généralement pas le résultat.

Pour l'entrée de multiples chaînes de caractères, un tableau à deux dimensions est généralement préférable. Cependant, ce n'est pas une règle absolue, comme dans le cas de l'algorithme d'allocation mémoire.

Implémentation d'une pile avec un tableau

char contenu[TAILLE];
int sommet=0;
void empiler(char valeur){
    contenu[sommet++]=valeur;
}
char depiler(void){
    if(sommet==0){
        printf("Vide\n");
    }
    else{
        return contenu[--sommet];
    }
}

18 novembre

Recherche de la plus petite puissance de 2 supérieure à un nombre

int puissance_de_deux(int x){
    int resultat=-1;
    for(int i=1;;i*=2){
        resultat++;
        if(i>=x){break;}
    }
    return resultat;
}

Pour calculer une puissance de 2, utilisez simplement 1<<n.

19 novembre

Utilisation de la fonction malloc

    char *memoire;
    memoire=malloc(TAILLE);
    memoire=malloc(TAILLE);

Conversion IEEE754 : hexadécimal en décimal (flottant simple précision)

#include <math.h>
float convertir(int nombre)
{
    int signe = (nombre & 0x80000000) ? -1 : 1; // Opérateur ET bit à bit pour le bit de signe
    int exposant = ((nombre >> 23) & 0xff) - 127; // Décalage puis ET bit à bit
    float mantisse = 1 + ((float)(nombre & 0x7fffff) / 0x7fffff); // Conversion des bits 22-0
    return signe * mantisse * pow(2, exposant);
}
int main()
{
    int valeur;
    scanf("%x",&valeur);
    float resultat = convertir(valeur);
    printf("%f", resultat);
    return 0;
}

20 novembre

Recherche binaire

int rechercher(int x){
    int gauche=0,droite=n-1; // Plage de k[gauche] à k[droite]
    while(droite>=0&&gauche<n&&gauche<=droite){
        int milieu = (gauche+droite+1)/2;
        if(k[milieu]==x){
            return 1;
        }
        else if(k[milieu]<x){
            gauche=milieu+1;
        }
        else{
            droite=milieu-1;
        }
    }
    return 0;
}

Ceci est un algorithme de recherche binaire - le tableau doit être trié par ordre croissant.

Tri à bulles

void echanger(int *a,int *b){
    int temp=*a;
    *a=*b;
    *b=temp;
}
void trier(int longueur, int tableau[]){
    for(int i=0;i<longueur-1;i++){
        for(int j=0;j<longueur-i-1;j++){
            if(tableau[j]>tableau[j+1]){
                echanger(&tableau[j],&tableau[j+1]);
            }
        }
    }
}

Fonctions de string.h

char *copier_chaine(char *dest,const char *src){
    char *p=dest;
    while (*dest++ = *src++);
    return p;
}
char *concatener_chaine(char *dest,const char *src){
    char *p = dest;
    while(*p){
        p++;
    }
    while(*p++ = *src++)
        ;
    return dest;
}

Macro pour la comparaison : #define min(a, b) ((a) < (b) ? (a) : (b))

Les macros offrent une syntaxe concise.

Fonctions courantes : inversion de chaîne et vérification de nombre premier

    int resultat = 0;
    while (nombre) {   // Inversion de nombre
        resultat = resultat * 10 + nombre % 10;
        nombre/=10;
    }
    return resultat;
}

Vérification de nombre premier :

int est_premier(int n) {
    for (int i = 2; i * i <= n; i++)
        if (n % i == 0)  // Si un facteur est trouvé, ce n'est pas premier
            return 0;
    return 1;
}

Lecture d'entrée

while(scanf("%s",&chaine)!=EOF){
    // Traitement
}

Bonne méthode de lecture. Dans CLion, utilisez Ctrl+D en mode débogage pour entrer EOF.

Listes chaînées

#include <stdlib.h>
struct element{
    int valeur;
    struct element* suivant;
};
struct element* ajouter_en_tete(int valeur,struct element*liste){
    struct element*nouveau= malloc(sizeof(struct element));
    nouveau->valeur=valeur;
    nouveau->suivant=liste;
    return nouveau;
}
struct element* supprimer_element(int valeur,struct element*liste){
    struct element* actuel,*precedent;
    for(actuel=liste,precedent=NULL;actuel!=NULL&&actuel->valeur!=valeur;precedent=actuel,actuel=actuel->suivant){
    }
    if(actuel==NULL)return liste;
    if(precedent==NULL)liste=liste->suivant;
    else
        precedent->suivant=actuel->suivant;
    free(actuel);
    return liste;
}
int main(){
    struct element* p;
    struct element* premier = NULL;
    premier = ajouter_en_tete(114514,premier);
    premier = ajouter_en_tete(1919810,premier);
    for(p=premier;p!=NULL;p=p->suivant){
        printf("%d\n",p->valeur);
    }
    premier = supprimer_element(1919810,premier);
    for(p=premier;p!=NULL;p=p->suivant){
        printf("%d\n",p->valeur);
    }
    return 0;
}

Opérations de base sur les listes chaînées, avec insertion en tête.

Opérations sur les pointeurs et les bits

Pointeurs restreints. Pointeurs de pointeurs. Solutions astucieuses pour des cas particuliers.

int (*p) [10] = malloc(sizeof(int)*200); - Généralemetn utilisé pour opérer sur une colonne de tableau à deux dimensions. p pointe vers un tableau de 10 éléments, avec 20 lignes. p++ passe à la ligne suivante, même colonne.

Opérations sur les bits

• i & (1 << j) : Lit le j-ième bit de i
• i &= ~(1 << j) : Met le j-ième bit de i à 0
• i |= (1 << j) : Met le j-ième bit de i à 1
• L'opération XOR peut être utilisée pour le chiffrement : a^b^b = a, où b est la clé et a^b est le texte chiffré.

Conversion décimal → binaire → hexadécimal

#include<stdio.h>
#include<string.h>
#include<math.h>
void convertir(char entree[],char binaire[],hexadecimale[]){
    char*p,*p1,c;int j,t;
    p=binaire;
    for(;*entree!='\0';entree++){
        t=*entree-'0';
        p+=2;
        for(j=0;j<3;j++){
            *p=t%2+'0';
            p--;t/=2;}
        p+=4;
        }
    *p='\0';
    p=binaire+ strlen(binaire)-1;
    p1=hexadecimale;
    for(t=0,j=0;p>=binaire;p--){
        t+=(*p-'0')*(int)pow(2,j++);
        if(t!=0&&(j%4==0||p==binaire)){
            if(t<10)*p1=t+'0';
            else *p1=t-10+'A';
            j=0;t=0;p1++;
        }
    }
*p1='\0';
    for(p1--;hexadecimale<p1;hexadecimale++,p1--){
        c=*hexadecimale;*hexadecimale=*p1;*p1=c;
    }

}
int main(){
char entree[]="357",binaire[20],hexadecimale[10];
    convertir(entree,binaire,hexadecimale);
    printf("%s,%s\n",binaire,hexadecimale);
}