Institute of Inf. Tech. - Informatikai intézet

Felhasználói eszközök

Eszközök a webhelyen

Nyomvonal: • questions • java_http_server • docker_integration_techniques • matrixok_kezelese • gdd_pelda • transzformacio • strukturak_c-ben • computer_system_security • evolution_of_software_integration_methods • alapveto_diagrammok
tanszek:oktatas:muszaki_informatika:strukturak_c-ben

Különbségek

A kiválasztott változat és az aktuális verzió közötti különbségek a következők.

Összehasonlító nézet linkje

tanszek:oktatas:muszaki_informatika:strukturak_c-ben [2024/02/13 19:40]
knehez létrehozva 		tanszek:oktatas:muszaki_informatika:strukturak_c-ben [2024/02/13 19:41] (aktuális)
knehez
Sor 1: Sor 1:
-==== Mátrixok használata ==== +**1. Feladat**: Olvasson be változó számú neveket ​és érdemjegyeket ​egy struktúrába és írassa ki az eredményt.
- +
-**1. feladat:** Adjunk össze két 3x3-as egész számokat tároló mátrix-ot ​és tároljunk le egy harmadikban ​az eredményt. Használjunk függvényt a mátrix elemeinek bekéréséhez. +
  
 <sxh c> <sxh c>
-#include <​stdio.h>​+#​include<​stdio.h> ​ // printf() és scanf() miatt kell 
 +#​include<​stdlib.h>​ // malloc() miatt kell
  
-#define SIZE 3 // a matrix-ok merete +struct Kurzus
-void readMatrix(int m[][SIZE])+
 { {
-    ​for(int sor = 0; sor < SIZE; sor++) +    ​char nev[30]; 
-    ​{ +    int jegy; 
-        for(int oszlop = 0; oszlop < SIZE; oszlop++) +};
-        { +
-            scanf("​%d",​ &​m[sor][oszlop]); +
-        } +
-    } +
-}+
  
 int main() int main()
 { {
-    ​int A[SIZE][SIZE]; // Matrix 1 +    ​struct Kurzus *ptr; 
-    int B[SIZE][SIZE]; // Matrix 2 +    int i, db; 
-    ​int C[SIZE][SIZE]; // eredmeny Matrix+    ​printf("​Hany hallgato van? "); 
 +    scanf("​%d",​ &db);
  
-    ​printf("Kerem az elso matrix elemeit: \n"); +    ​ptr = (struct Kurzus*) malloc ​(db * sizeof(struct Kurzus));
-    readMatrix(A); +
-    printf("Kerem az masodik matrix elemeit: \n"); +
-    readMatrix(B);+
  
-    for(int sor = 0; sor < SIZE; sor++)+    for(i = 0; i < db; ++i)
     {     {
-        ​for(int oszlop = 0; oszlop < SIZE; oszlop++) +        ​printf("Kerem a nevet es a jegyet:​\n"​); 
-        ​{ +        ​scanf("​%s %d", (ptr + i)->nev, &ptr[i].jegy);
-            C[sor][oszlop] = A[sor][oszlop] ​+ B[sor][oszlop]; +
-        }+
     }     }
  
- +    ​printf("​Osszesen:​\n"​);​ 
-    ​printf("​\nMatrixok osszege: A+B = \n"​);​ +    for(i = 0; i < db ; ++i)
-    for(int sor = 0; sor < SIZE; sor++)+
     {     {
-        ​for(int oszlop = 0; oszlop < SIZE; oszlop++) +        printf("​%s\t%d\n", ​ptr[i].nev, (ptr + i)->jegy);        ​
-        { +
-            ​printf("​%d ", ​C[sor][oszlop]); +
-        } +
-        printf("​\n"​); ​ // soronkent uj sor+
     }     }
 } }
 </​sxh>​ </​sxh>​
  
-**2. feladat:** Az első feladatban a <sxh c>​readMatrix()<​/sxh> függvényt cseréljük le: <sxh c>void readMatrix(int ** m)</sxh> ​-ra és próbáljuk meg mi történik és magyarázzuk meg miért?  +**2. Feladat**: Láncolt lista: készítsünk egy //int szam//-ot tartalmazó struktúrát,​ ami tartalmaz egy mutatót egy önmagával megegyező típusra //next// néven.
- +
-**3. feladat:** Az első feladatban megadott feladatot oldjuk meg pointerekkel is.+
  
 <sxh c> <sxh c>
 #include <​stdio.h>​ #include <​stdio.h>​
- +struct Elem
-#define SIZE 3 // a matrix-ok merete +
-void readMatrix(int *m)+
 { {
-    ​for(int i = 0; i < SIZE * SIZE; i++) +    int szam; 
-    ​{ +    ​struct Elem *next; 
-        scanf("​%d",​ (m + i)); +};
-    } +
-}+
  
 int main() int main()
 { {
-    int A[SIZE][SIZE];​ // Matrix 1 
-    int B[SIZE][SIZE];​ // Matrix 2 
  
-    printf("​Kerem az elso matrix elemeit: \n"); +} 
-    ​readMatrix(&​A[0][0]);​ +</​sxh>​
-    printf("​Kerem az masodik matrix elemeit: \n"​);​ +
-    readMatrix(&​B[0][0]);​+
  
-    int C[SIZE][SIZE];​ // eredmeny Matrix+**3. Feladat**: Láncolt lista: az előzőből hozzunk éltre két darabot dinamikusan,​ az első a másodikra mutasson.
  
-    for(int i = 0; i < SIZE * SIZE; i++) +<sxh c> 
-    { +#include <​stdio.h>​ 
-        ​*(&​C[0][0] + i) = *(&​A[0][0] + i) + *(&​B[0][0] + i); +#include <​stdlib.h>​ 
-    }+struct Elem 
 +{ 
 +    int szam; 
 +    ​struct Elem *next; 
 +};
  
-    printf("​\nMatrixok osszege: A+B = \n"); +int main() 
-    ​for(int sor = 0; sor < SIZE; sor++) +{ 
-    ​{ +    ​struct Elem* e1 = (struct Elem*) malloc(sizeof(struct Elem)); 
-        for(int oszlop ​= 0; oszlop < SIZE; oszlop++) +    ​struct Elem* e2 = (struct Elem*) malloc(sizeof(struct Elem)); 
-        { +    // osszekotes első variacio 
-            printf("%d ", C[sor][oszlop]); +    ​e1->​next = &e2[0]; 
-        } +    ​// osszekotes 2. variacio 
-        ​printf("​\n"​);  // soronkent uj sor +    ​e1[0].next = e2;
-    ​}+
 } }
 </​sxh>​ </​sxh>​
  
-**4. feladat:** Ellenőrizzük, hogy a felhasználótól ​bekért 3x3-as mátrix felső háromszög típusú-e?+**4. Feladat**: Láncolt lista: Készítsünk egy függvényt, ami kiírja a lista összes elemét. Majd kérjünk be a felhasználótól ​tetszőleges számú dinamikusan létrehozott listaelemet.
  
 <sxh c> <sxh c>
 #include <​stdio.h>​ #include <​stdio.h>​
 +#include <​stdlib.h>​
  
-#define SIZE 3 // a matrix-ok merete +typedef struct Elem  ​// azért lett typedef, hogy kényelmes függvényparaméter lehessen
-void readMatrix(int m[][SIZE])+
 { {
-    ​for(int sor = 0; sor < SIZE; sor++)+    int szam; 
 +    struct Elem *next;  // a '​struct Elem' nem mas mint onmaga 
 +} Elem; 
 + 
 +void printList(Elem * head) 
 +{ 
 +    Elem * current = head; 
 + 
 +    while (current != NULL)
     {     {
-        ​for(int oszlop = 0; oszlop < SIZE; oszlop++) +        ​printf("%d\n", ​current->​szam); 
-        { +        ​current = current->​next;​
-            scanf("​%d", ​&​m[sor][oszlop]); +
-        ​}+
     }     }
 } }
Sor 114: Sor 97:
 int main() int main()
 { {
-    int A[SIZE][SIZE];+    int db; 
 +    printf("​Hany elemet ad meg?"​);​ 
 +    scanf("​%d",​ &db);
  
-    ​printf("​Kerem a matrix elemeit: \n"); +    ​Elem *last = NULL; 
-    ​readMatrix(A);​ +    ​Elem *first ​= NULL; 
- +    for(int ​i=0; i < db; i++)
-    int felsoHaromszog ​= 1; +
-    // Hogyan jovunk ra a megoldasra?​ +
-    // +
-    // 1 2 3   [0,0] [0,1] [0,2] +
-    // 0 4 5 =>[1,0] [1,1] [1,2] +
-    // 0 0 6   [2,0] [2,1] [2,2] +
-    // +
-    // Mi a közös a három 0 érték indexeiben?​ +
-    // - az hogy a sor index erteke mindig nagyobb mint +
-    // az oszlop index!! +
-    // +
-    for(int ​sor = 0; sor < SIZE; sor++)+
     {     {
-        ​for(int oszlop ​= 0; oszlop < SIZE; oszlop++)+        ​Elem* e = (Elem*) malloc(sizeof(Elem));​ 
 +        e->​next ​= NULL;  // probaljuk ki úgy is, hogy ezt a sort kitoroljuk. Magyarazzuk meg miert tortenik? 
 +        if(last != NULL) // ha nem az elsőt töltjük fel
         {         {
-            ​// +            ​last->next = e;
-            // a foatlo alatti elemeknek 0-nak kell lenniuk +
-            // +
-            if(sor ​> oszlop && A[sor][oszlop]!=0) +
-            { +
-                felsoHaromszog = 0; +
-            }+
         }         }
 +        else // ha az elsőt töltjük fel, az elsőt eltároljuk,​ mert e nélkül elveszne az első eleme a listának
 +        {
 +            first = e;
 +        }
 +        printf("​Kerem az %d.-t:",​ i);
 +        scanf("​%d",​ &​e->​szam);​
 +        last = e; // osszekotjuk a ket strukturat
     }     }
-    ​if(felsoHaromszog) +    ​printList(first);
-    { +
-        printf("​felso haromszog matrix"​);​ +
-    } +
-    else +
-    { +
-        printf("​nem felso haromszog"​); +
-    }+
 } }
 +</​sxh>​
  
 +**5. Feladat**: Értsük meg jobban a typedef használatát a _types.h kódrészlete alapján:
 +
 +<sxh c>
 +/* sys/​x86/​include/​_types.h in FreeBSD */
 +/* this is machine dependent */
 +#​ifdef ​ __LP64__
 +typedef unsigned long       ​__uint64_t;​
 +#else
 +__extension__
 +typedef unsigned long long  __uint64_t;
 +#endif
 +...
 +...
 +typedef __uint64_t ​ __size_t; ​  
 </​sxh>​ </​sxh>​
  
-**5. feladat:** Írjon C programot, ami meghatározza,​ hogy egy mátrix ritka mátrix-e? Egy ritka mátrix olyan mártix aminek legalább elemeinek a fele 0. +A fenti kódpélda az **//unsigned long long//** ot rövidíti ​**//​__size_t//​**-nek (64 bites rendszereken). A következő kódrészlet 3 féle struktúradefiníciót alkalmaz:
- +
-**6. feladat:** Írjon C programot, ami bekér a felhasználótól egy 3x3-as mátrixot és kiírja a transzponáltját.+
  
 <sxh c> <sxh c>
 #include <​stdio.h>​ #include <​stdio.h>​
 +#include <​stdlib.h>​
  
-#define SIZE 3 // a matrix-ok merete +/* uj tipust hozunk létre Item neven. 
-void readMatrix(int m[][SIZE])+   A struct elem_t helyett Item-et irhatunk kesobb 
 +*/ 
 +typedef struct elem_t
 { {
-    ​for(int sor = 0; sor < SIZE; sor++) +    ​char *text; 
-    ​{ +    int count; 
-        for(int oszlop = 0; oszlop < SIZE; oszlop++) +    ​struct elem_t *next; /* itt meg nem lehet roviditeni */ 
-        { +} Item;
-            scanf("​%d",​ &​m[sor][oszlop]); +
-        } +
-    } +
-}+
  
-int main()+/* normal struktura definicio */ 
 +struct item
 { {
-    ​int A[SIZE][SIZE]; +    ​char *text; 
-    int E[SIZE][SIZE]; +    int count; 
-    ​printf("​Kerem a matrix elemeit: \n"); +    ​struct item *next; 
-    ​readMatrix(A);+};
  
-    ​// Hogyan jovunk ra a megoldasra? +/* 
-    // Transzpontalt matrix pelda: +* ez valojaban egy nevtelen struktura 
-    // +*/ 
-    // 1 2 3    1 4 7 +struct 
-    // 4 5 6 => 2 5 8 +{ 
-    ​// 7 8 9    3 6 9 +    ​int i; 
-    // +    ​char c; 
-    // A matrix [i][j] elemét [j][i]-re kell cserelni +} nevtelen;
-    for(int sor = 0; sor < SIZE; sor++) +
-    ​{ +
-        for(int oszlop = 0; oszlop < SIZE; oszlop++) +
-        { +
-            E[sor][oszlop] = A[oszlop][sor]; +
-        } +
-    }+
  
-    for(int sor = 0; sor < SIZE; sor++) +int main(void) 
-    { +{ 
-        ​for(int oszlop ​= 0; oszlop < SIZE; oszlop++) +    // mutato a "​struct item"​-re 
-        { +    struct item *pi = (struct item *)malloc(sizeof(struct item));; 
-            ​printf("%d ", E[sor][oszlop]); +    ​pi->​count = 10; 
-        } + 
-        ​printf("​\n"​); +    // Roviditett hasznalata a "struct item_t"-nek 
-    ​}+    Item *iI = (Item *)malloc(sizeof(Item)); 
 +    ​iI->​count = 5; 
 +    ​iI->​next = iI; // onmagara mutat (csak a pelda kedveert) 
 + 
 +    // nevtelen structura 
 +    nevtelen.i = 9; 
 +    ​nevtelen.c = '​x';​
 } }
 </​sxh>​ </​sxh>​
  
-**7. feladat:** Írjon C programot, ami összeszoroz két mátrixot.+**6. Feladat**: A 4. példához készítsünk egy **//Elem* pop()//** függvényt, ami az első elemet eltávolítja a listából
 <sxh c> <sxh c>
-#include <​stdio.h>​ +Elem* pop(Elem *first)
- +
-#define MAX_SOR 3 +
-#define MAX_OSZLOP 3 +
-void readMatrix(int m[][MAX_OSZLOP])+
 { {
-    ​for(int sor = 0; sor < MAX_SOR; sor++) +    ​Elem *ret = first->​next; 
-    ​{ +    ​free(first); 
-        for(int oszlop = 0; oszlop < MAX_OSZLOP; oszlop++) +    ​return ret;
-        { +
-            scanf("​%d",​ &​m[sor][oszlop]); +
-        } +
-    ​}+
 } }
 +</​sxh>​
  
-int main()+**7. Feladat**: A 4. példához készítsünk egy **//void sort(Elem*)//**, ami sorbarendezi növekvő sorrendbe a lista elemeit, az értékek módosításával. 
 + 
 +<sxh c> 
 +void sort(Elem *first)
 { {
-    ​int A[MAX_SOR][MAX_OSZLOP]; +    ​Elem *e1, *e2; 
-    ​int B[MAX_SOR][MAX_OSZLOP]; +    ​e1 = first; 
-    ​int C[MAX_SOR][MAX_OSZLOP];​ +    ​while(e1->next != NULL)
-    printf("Kerem az A matrix elemeit: \n"​);​ +
-    readMatrix(A);​ +
-    printf("​Kerem a B matrix elemeit: \n"​);​ +
-    readMatrix(B);​ +
- +
- +
-    for (int sor = 0; sor < MAX_SOR; sor++)+
     {     {
-        ​for (int oszlop ​= 0; oszlop < MAX_OSZLOP; oszlop++)+        ​e2 = e1->next; 
 +        while(e2 != NULL)
         {         {
-            ​int sum = 0; +            ​if(e2->​szam ​< e1->szam)
-            for (int i = 0; i < MAX_OSZLOP; i++)+
             {             {
-                ​sum += (*(*(A + sor) + i)) * (*(*(B + i) + oszlop));+                ​int tmp = e2->​szam;​ 
 +                e2->szam = e1->​szam;​ 
 +                e1->szam = tmp;
             }             }
-            ​*(*(C + sor) + oszlop) ​= sum;+            ​e2 = e2->next;
         }         }
 +        e1 = e1->​next;​
     }     }
 +}
 +</​sxh>​
  
  
-    for(int sor = 0; sor < MAX_SOR; sor++) 
-    { 
-        for(int oszlop = 0; oszlop < MAX_OSZLOP; oszlop++) 
-        { 
-            printf("​%d ", C[sor][oszlop]);​ 
-        } 
-        printf("​\n"​);​ 
-    } 
-} 
  
-</​sxh>​ 
- 
-**8. feladat:** Írja át az előző példában a sum += (*(*A + sor .... -t az egyszerűbb indexes A[i][j]- alakra! 
-<sxh c> 
-sum += A[sor][i] * B[i][oszlop];​ 
-</​sxh>​ 
  
  
tanszek/oktatas/muszaki_informatika/strukturak_c-ben.1707853256.txt.gz · Utolsó módosítás: 2024/02/13 19:40 szerkesztette: knehez

Eszközök az oldalon

Hacsak máshol nincs egyéb rendelkezés, ezen wiki tartalma a következő licenc alatt érhető el: CC Attribution-Share Alike 4.0 International
CC Attribution-Share Alike 4.0 International Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki