1.
#include <stdio.h>

typedef struct { double re,im; } Komplex;

Komplex szorzo(Komplex a, Komplex b){
    Komplex eredmeny;
    eredmeny.re = a.re*b.re - a.im*b.im;
    eredmeny.im = a.re*b.im + b.re*a.im;
    return eredmeny;
}

int main(){
    Komplex x={3,-2}, y={5,7}, z;

    z = szorzo(x,y);
    printf("%g%+gi\n",z.re,z.im);
    
    return 0;
}
==============================================================
2.
#include <stdio.h>
#include <stdlib.h>

void rendez(double tomb[], int meret){
    int i,j,minindex;
    
    // Az i. tömbelem helyére becseréljül az utána lévő tömbrészből a legkisebbet
    
    for(i=0; i<meret; i++){
        
        // Megkeressük a legkisebbet a még renddezetlen részen
        
        minindex=i; // Minimumkeresés: a minindex tárolja az eddig megtalált legkisebbet
        for(j=i+1; j<meret; j++){
            if(tomb[j]<tomb[minindex])
                minindex=j;
        }

        // Ha nem a helyén van, megcseréljük

        if(minindex!=i){
            double temp=tomb[i];
            tomb[i]=tomb[minindex];
            tomb[minindex]=temp;
        }
    }
}

int hasonlit(const void *tombelem1, const void *tombelem2){
    double *a,*b;
    a=(double*)tombelem1;
    b=(double*)tombelem2;
    if(*a<*b)return -1; // Ha az 'a' által mutatott tömbelem kisebb, mit a 'b' által mutatott.
    if(*a>*b)return 1;
    return 0; // Ha egyenlőek
}

int main(){
    double tomb1[10]={8,-5,1,7,-3,2,10,0,9,4};
    double tomb2[10];
    double *tomb3,*tomb4;
    int i;

    // dinamikus tömbök létrehozása

    tomb3 = (double*)malloc(10*sizeof(double));
    tomb4 = (double*)malloc(10*sizeof(double));
    if(tomb3==NULL || tomb4==NULL) return 1; // sikertelen foglalás

    // átmásoljuk tomb1 tartalmát a böbbibe

    for(i=0; i<10; i++)
        tomb2[i] = tomb3[i] = tomb4[i] = tomb1[i];

    rendez(tomb1,10); // normál tömb rendezése
    rendez(tomb3,10); // dinamikus tömb rendezése: semmi különbség nincs!

    qsort(tomb2,10,sizeof(double),hasonlit);
    qsort(tomb4,10,sizeof(double),hasonlit);

    // kiírás ellenőrzésképpen

    printf("\n%g", tomb1[0]); for(i=1; i<10; i++)printf(", %g", tomb1[i]);
    printf("\n%g", tomb2[0]); for(i=1; i<10; i++)printf(", %g", tomb2[i]);
    printf("\n%g", tomb3[0]); for(i=1; i<10; i++)printf(", %g", tomb3[i]);
    printf("\n%g", tomb4[0]); for(i=1; i<10; i++)printf(", %g", tomb4[i]);
    printf("\n");

    // A dinamikus tömbök felszabadítása

    free(tomb3);
    free(tomb4);

    return 0;
}
==============================================================
3.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

typedef struct {
    char nev[40+1];  // A lezáró nullának is kel hely.
    int azonosito;
} Ember;

void kiir(Ember tomb[], int meret){
    int i;
    for(i=0; i<meret; i++)
        printf("%-15s %d\n",tomb[i].nev,tomb[i].azonosito);
    printf("\n");
}

void rendez_a(Ember tomb[], int meret){
    int i,j,minindex;
    
    for(i=0; i<meret; i++){
        
        minindex=i;
        for(j=i+1; j<meret; j++){
            if(tomb[j].azonosito<tomb[minindex].azonosito) // Ha megfordítjuk a relációs jelet, csökkenő sorrendbe rendez.
                minindex=j;
        }

        if(minindex!=i){
            Ember temp=tomb[i];
            tomb[i]=tomb[minindex];
            tomb[minindex]=temp;
        }
    }
}

void rendez_b(Ember tomb[], int meret){
    int i,j,minindex;
    
    for(i=0; i<meret; i++){
        
        minindex=i;
        for(j=i+1; j<meret; j++){
            if(strcmp(tomb[j].nev,tomb[minindex].nev)<0) // Ha megfordítjuk a relációs jelet, csökkenő sorrendbe rendez.
                minindex=j;
        }

        if(minindex!=i){
            Ember temp=tomb[i];
            tomb[i]=tomb[minindex];
            tomb[minindex]=temp;
        }
    }
}

int hasonlit_a(const void *a, const void *b){
    Ember * p1 = (Ember*)a;
    Ember * p2 = (Ember*)b;
    return p1->azonosito - p2->azonosito; // Ha a -1-szeresét adjuk vissza, csökkenőbe rendez.
}

int hasonlit_b(const void *a, const void *b){
    Ember * p1 = (Ember*)a;
    Ember * p2 = (Ember*)b;
    return strcmp(p1->nev, p2->nev); // Ha a -1-szeresét adjuk vissza, csökkenőbe rendez.
}

int main(){
    char *nevek[10]={"Szent Istvan","Kossuth Lajos","Hunyadi Matyas","Deak Ferenc",
                     "Maria Terezia", "Dozsa Gyorgy", "Pazmany Peter", "Rakoczi Ferenc",
                     "Konyves Kalman", "Mikes Kelemen"};
    int i;
    Ember *dintomb;

    dintomb = (Ember*)malloc(sizeof(Ember)*10); // 10 elemű din. tömböt foglalunk
    if(dintomb==NULL){
        printf("Hiba: sikertelen foglalas.\n");
        exit(1);
    }

    srand(time(NULL));
    for( i=0; i<10; i++){
        strcpy(dintomb[i].nev,nevek[i]);
        dintomb[i].azonosito = rand();
    }

    printf("Az eredeti tomb:\n");
    kiir(dintomb,10);

    rendez_a(dintomb,10);
    printf("Azonosito szerint rendezve:\n");
    kiir(dintomb,10);

    rendez_b(dintomb,10);
    printf("Nev szerint rendezve:\n");
    kiir(dintomb,10);

    qsort(dintomb,10,sizeof(Ember),hasonlit_a);
    printf("Azonosito szerint rendezve:\n");
    kiir(dintomb,10);

    qsort(dintomb,10,sizeof(Ember),hasonlit_b);
    printf("Nev szerint rendezve:\n");
    kiir(dintomb,10);

    free(dintomb);

    return 0;
}