Tamás Péter (D. 424) Mechatronika, Optika és Gépészeti Informatika Tanszék (D 407)

Tamás Péter (D. 424) Mechatronika, Optika és Gépészeti Informatika Tanszék (D 407) 1

Előadás Bevezetés az informatikába Adatszerkezetek Algoritmusok, programozási technológiák Számítástudomány alapjai Számítógépek felépítése, működési módjai Számítógépek hardverelemei Operációs rendszerek, UNIX Számítógépes hálózatok, Internet Adatbázisok Számítógépes grafika I. Számítógépes grafika II. Számítógépes grafika III. ZH (előadás) Reklamáció 2

I. Bevezetés az informatikába 3

I.1 A számítógép működése I.2 Adatok I.3 Program I.4 Adatok + Program = Objektum 4

I.1 A számítógép működése I.1.1 A számítógép működésének elvi alapjai Leegyszerűsített megfogalmazás - Az információ a valóság (vagy egy részének) visszatükröződése. [Neumann] Az információmennyiség mértékegysége a bit (nem csak az adatmennyiség mértékegysége). Ha egy eldöntendő kérdésre egyforma valószínűséggel adhatók különböző válaszok, akkor az e kérdésre adott bármely válasz pontosan 1 bit információt hordoz. I.1.2 A számítógép felépítése, hardver elemek I.1.2.1 A Neumann elv A számítógép 1. Elektronikus működésű, 2. Az információ bináris ábrázolása, 3. Tárolt programmal programozható 4. A program utasításait az adatokkal együtt a központi memóriában tárolja, 5. Univerzálisan használható, a feladatok megoldására különböző programok 6. Soros utasítás-végrehajtás 7. A gépnek öt alapvető funkcionális egységből kell állnia: a) bemeneti egység, b) memória, c) aritmetikai és logikai egység, d) vezérlőegység, e) kimeneti egység, 5

I.1.3 Korszerű számítógép p1 p2 p3 p4 a1 a2 a3 a4 Processzor Memória I.1.4 Hardver működés I.1.4.1 Kapcsolat a Busz Cím Adat Vezérlő Busz I.1.5 Processzor ALU Vezérlő egység Speciális funkciókkal I/O egységek Akkumulátor-regiszter - a műveletekhez Adatszámláló regiszter - Az adatok olvasás-/íráskor a memóriacím Utasításszámláló regiszter A soron következő utasítás címe Utasításregiszter - A következő programutasítás kódja. Címzést segítő regiszter Bázis(cím)regiszter Az operandusok címzéséhez Indexregiszterek additív cím adatsorok címzését segítik Egyéb Állapotregiszter, vezérlő regiszter Veremmutató regiszter (Stack Pointer) Cím Memória Fizikai cím 6

I.1.6 ADAT+PROGRAM I.1.6.1 Utasítás-végrehajtás Utasításszámláló regiszter Utasításregiszter (aritmetikai-, logikai utasítások) Adatok (regiszterből, memóriából, regiszterbe, memóriába) MOV AX,1234h ;0B8h 34h 12h - szám (1234h) az AX reg.-be MUL WORD PTR [5678h] ;0F7h 26h 78h 56h - szor a cím adatával (extra szegmensen) MOV [5678h],AX ;0A3h 78h 56h - AX a címre I.1.6.2 Címzési módszerek Direkt címzés Virtuális címzés Szegmens szegmens + offset Lapozás laptábla dir + laptábla + offset Cím Memória Fizikai cím I/O port címek 7

I.2. Adatkezelés I.2.1 Adattárolási elvek Információtárolás = adat, mértékegységek 1 byte = 8 bit 1 kbyte = 1024 byte 1 Mbyte = 1024 kbyte 1 Gbyte = 1024 Mbyte 1 Tbyte = 1024 Gbyte I.2.1.1 Elemi adatok I.2.1.1.1 Számok Adattárolás kettes számrendszerben (Neumann) Egész számok (fixpontos) bináris ábrázolás (hexadecimális leírás) byte (char) sbyte (signed char), előjelbit, negatív számok komplemens ábrázolása int, long (long int)(2, 4, ) 2 10 = 0000010 2 az egyes komplemens 11111101 2 kettes komplemens = egyes komplemens + 1 11111110 2 = 2 10 0 10 = 2 10 + 2 10 = 11111110 2 + 0000010 2 = 0000000 2 8 elég csak összeadni

Hexadecimális számok 0 10 15 10 0 16 F 16 0000 2 1111 2 0 10 255 10 0 16 FF 16 00000000 2 11111111 2 Valós számok lebegőpontos X = E M*A K M Mantissza E Előjel K Karakterisztika I.2.1.1.2 Karakterek a szám tört része a mantissza előjele az A alapszám előjeles kitevője EKKKKKKKMMMMMMMMMMMMMMMMMMMMMMM ASCII - American Standard Code for Information Interchange karakterkészlet és karakterkódolási szabvány, a latin abc (angol, és sok nyugat-európai nyelv) UCS - Universal Character Set ISO, Unicode Consortium. Unicode Standard I.2.1.1.3 String karaktersorozat Szövegek Vége jel C ALMA - Pascal 65 76 77 65 0 4 65 76 77 65 Hossz 9

I.2.2 Összetett adatok I.2.2.1 Rekord logikailag összefüggő (nem azonos típusú) elemi adatok halmaza egyszerű mező+egyszerű mező+ I.2.2.2 File pl. logikailag összefüggő rekordok halmaza I.2.2.3 Adatbázis (pl. relációs) file-ok halmaza Adatok valódi kétdimenziós táblázatokban Az oszlopok az attribútumok (oszlophalmaz - reláció) az elemi (atomi) adattípusok az értékek A sorok a reláció előfordulások halmazát alkotják, nincs két azonos sor A sorok és oszlopok felcserélhetők A táblázatok között is lehet kapcsolat A relációt névvel azonosítjuk 10

I.2.3 Grafikus adatok I.2.3.1 Vektoros grafika CDR I.2.3.2 Raszteres grafika BMP DIB JPG I.2.3.3 Meta grafika Pl. a True Type WYSWYG WMF, EMF 11

I.2.4 Geometriai modell adatok I.2.4.1 Pont 8 5 6 3 1 2 I.2.4.2 Él I.2.4.3 Felület 7 Sorszám x-koordináta y-koordináta z-koordináta Következő csúcs 1 0.0 0.0 0.0 2 2 40.0 0.0 0.0 3 3 40.0 20.0 0.0 4 4 0.0 20.0 0.0 5 5 0.0 0.0 20.0 6 Sorszám Él egyenlete 6 kezdőpont 40.0 végpont 0.0 Következő 20.0 él 7 1 7 L1 40.01 220.0 20.0 2 8 2 8 L2 0.02 320.0 20.0 3 0 // nincs 3 L3 3 4 4 Sorszám Felület 4 egyenlete Határélek L4 Következő 4 felület 1 5 1 5 F1 L5 1,2,3,4 1 2 5 6 2 6 F2 L6 9,10,11,12 2 3 6 7 3 Sorszám 7 Felület F3 egyenlete L74,5,8,12 Határélek 3 4 7 n x n x 2 n x Következő felület 4 8 1 F4 L8 8,9,10,11 F1 41,2,3,4 5 8 1,23 12,3 3 123 2 5 9 2 F5 L92,6,7,10 F2 9,10,11,12 5 6 6 4,56 45,6 4 456 3 6 10 3 F6 L10 3,7, 8,11 F3 4,5,8,12 6 0 // nincs 7 7,89 78,9 5 789 4 11 4 L11 F4 8,9,10,11 7 8 9,87 98,7 6 987 5 12 5 L12 F5 2,6,7,10 8 5 6,54 65,4 0 // nincs 654 6 I.2.4.4 Boundary REPresentation 6 F6 3,7, 8,11 3,21 32,1 321 0 // nincs 12

I.2.4.5 CSG Név X1 Y1 Z1 X2 Y2 Z2 T1-25 -5-5 25 5 5 Név X1 Y1 Z1 X2 Y2 Z2 T2-3 -25-3 3 25 3 Név C1 Jellemzés T1 T2 \ Név X1 Y1 Z1 X2 Y2 Z2 R H1 0 0-15 0 0 15 2 Név C2 Jellemzés C1\H1 Mindegyik bitsor! Hogyan értelmezzük 13

I.3. Algoritmus és program Algoritmus olyan tevékenységsorozatot, részletes útmutatást, receptet, értünk, amely valamely felmerült probléma megoldását célozza. I.3.1 Algoritmuselemek és program Böhm Jacopini tétele Minden algoritmus leírható az alábbi logikai struktúrákkal I.3.1.1 Rákövetkezés (konkatenáció) I.3.1.2 Választás (alternáció) i p h I.3.1.3 Ciklus (iteráció) i/h i/h p h/i p h/i 14

I.4. Objektum Program (1) Adat (2) Objektum Kiadványszerkesztés Word -,DOC Táblázatkezelés Excel -.XLS CAD AutoCad-.DXF Adatbáziskezelés Access -.MDB I.4.1. Computer Integrated Manufacturing Windows társítás CAD ADATOK CAQ CAPP CAP CAM CAE Computer Aided Design Computer Aided Manufacturing Computer Aided Engineering Computer Aided Processing Computer Aided Process Planning Computer Aided Quality Control CIM=ΣCAxx 15

I.4.2. Industry 4.0 16

II. Programozási technológiák 17

II.1 A gépi kódú program Az algoritmuslépések kódja + memória címek. II.2 Programkészítő programok MOV AX,1234h ;0B8h 34h 12h - szám (1234h) az AX reg.-be MUL WORD PTR [5678h] ;0F7h 26h 78h 56h - szor a cím adatával (extra szegmensen) MOV [5678h],AX ;0A3h 78h 56h - AX a címre Forrásnyelvű program Fordító/Interpreter Futtatható program Programozási nyelv generációk Generation of Language 1GL: gépi kód 2GL: assembly (mnemonic) 3GL: magas-szintű procedurális FORTRAN, PASCAL, C 4GL: probléma orientált Funkcionális: LISP (LISt Processing), Logikai: PROLOG (PROgraming LOGics), Adatbázis kezelés: SQL, Objektum-orientált: C++, JAVA. C#, Komponens alapú fejlesztők. 5GL: természetes nyelvek??? 18

II.3. Adatok és programok II.3.1 Adatkezelés Case sensitive [const readonly] típus_név nev[, ][ = kez_dért]? Egészek byte / sbyte 0..255 / -128..127 1 byte ushort / short 0..65 535 / -32 768..32 767 2 byte uint, int 0.. 4 294 967 295 / -2 147 483 648..2 147 483 648.. 8 byte Logikai típus bool false..true true, false 1 byte Lebegőpontos (valós) típus float -3.4 10 38.. 3.4 10 38 4 byte double ±5.0 10 324.. ±1.7 10 308 1.3, 2.1e6, 3.4F, 4.2L 8 byte decimal (-7.9 x 10 28.. 7.9 x 10 28 ) / (10 0.. 28 ) 28, 29 számjegy Betű char A, \n, \t (!!!) 2 byte string Alma n*2byte Felsorolt enum enum szam {egy, ketto, harom //0,1,2 enum ez {a=6,b=11 //0..15 szam.ketto 19

II.3.2 Alap algoritmus elemek II.3.2.1 Rákövetkezés (konkatenáció) int i = 3; int j = 4; int k = i + j; II.3.2.2 Választás (alternáció) if (i > j) { k = i - j; else { k = j - i; II.3.2.3 Ciklus (iteráció) i = 0; k = 0; while (i < 10) { k += i++; p i h p i/h h/i 21

II.4. Alprogramok, függvények típus nev ([paraméterek]) { // függvénytörzs [lokális definíciók, deklarációk] [utasítások] [return [érték]; // ha van] call fv call fv fv return SP nev([param1, param2, ]); i = nev([param1, param2, ]); int main () { 22

II.5. Objektum-osztály adatok+programok Rejtett adatok a középpont koordinátáinak Program Adat Objektum Konstruktor Property - Metódusok a középpont adatainak írására, olvasására Virtuális kerületszámítás Virtuális területszámítás 23

Rejtett adat a sugárra Property - Metódus a sugár írására, olvasására A kör kerületszámítása A kör területszámítása Rejtett adatok az oldalakra Property-k - Metódusok az oldalak írására, olvasására A téglalap kerületszámítása A téglalap területszámítása 24

// II.5.1 Osztály információ struktúra minta // példány adott struktúrájú adathalmaz class Síklap { // Síklap osztály // Belső tárolók // II.5.2 Adatmezők adatok tárolása protected double kx; // A kpont x koordinátájának tárolója protected double ky; // A kpont y koordinátájának tárolója // Nem publikus tulajdonságok // II.5.3 Tagfüggvények, metódusok adatok feldolg // speciális metódusok konstruktor, destruktor public Síklap() { // Konstruktor kx = 0; // Attribútumok ky = 0; // Attribútumok // II.5.4 Attribútumok szabályozott hozzáférés public double ox { // A középpont x koord. get { // Olvasás return kx; set { // Írás kx=value; 25

public double oy { // A középpont y koordinátája get { // Olvasás return ky; set { // Írás ky=value; // II.5.5 Az adatrejtés elve - (private, public, protected) saját, // nyilvános és védett elemek // II.5.6 Sokoldalúság az osztályhierarchiában // korai és késői kötés virtuális és dinamikus függv // absztrakt elemek public virtual double ker() { // Alap kerület return 0; public virtual double ter() { // Alap terület return 0; // A síklap alaposztály 26

// II.5.7 Osztályok hierarchiája egyszeres (és többszörös) öröklődés // Például a körlap class Körlap : Síklap { // Körlap oszt. a siklap leszarm. // Belső tároló private double r; // A sugár tárolója public Körlap() { // Konstruktor kx = 0; // Attribútumok ky = 0; // Attribútumok public double sugar { // A sugár tul. get { // Olvasás return r; set { // Írás r = value; // késői kötés virtuális és dinamikus fv public override double ker() { //A ker. return 2*r*Math.PI; public override double ter() { //A ter. return Math.PI*Math.Pow(r, 2); // Az egyik leszármazott 29

// Például a téglalap class Téglalap : Síklap { // Teglalap osztály a siklap leszarm. // Belső tárolók private double a; private double b; public Téglalap() { // Konstruktor kx = 0; // Attribútumok ky = 0; // Attribútumok public double a_oldal { // Az a_oldal get { // Olvasás return a; set { // Írás a = value; public double b_oldal { // A b_oldal get { // Olvasás return b; set { // Írás b = value; public override double ker() { //A kerület return 2 * (a + b); public override double ter() { //A terület return a*b; 30

// Példa körlap és téglalap példány // Körlap k = new Körlap(); k.ox = 10; k.oy = 10; Console.Write("A kör sugara="); k.sugar=convert.todouble(console.readline()); Console.WriteLine("A kör kerülete={0,8:f2",k.ker()); Console.WriteLine("A kör területe={0,8:f2",k.ter()); // Téglalap t = new Téglalap(); Console.Write("Az a oldal="); t.ox = 0; t.oy = 0; t.a_oldal = Convert.ToDouble(Console.ReadLine()); Console.Write("A b oldal="); t.b_oldal = Convert.ToDouble(Console.ReadLine()); Console.WriteLine("A téglalap kerülete={0,8:f2", t.ker()); Console.WriteLine("A téglalap területe={0,8:f2", t.ter()); // 33

II.6. A Windows működése eseményvezérelt program Windows Message queue WinMain Message Loop CallBack namespace WindowsFormsApplication1 { public partial class Form1 : Form { public Form1() { InitializeComponent(); private void button1_click( object sender, EventArgs e) { Console.Beep(); Case DefWindowProc non pre emptive multitasking 35

II.7 Windows multiprogramozás (preemptive) Rendszer és alkalmazás várakozó sorok Eszközök Nyomtató Lemezek Billentyûzet Egér Üzenetek Várakozó sor Rendszer Alkalmazások Üzenetek 32 bites szál várakozó sor 32 bites szál várakozó sor 32 bites szál várakozó sor elsõdleges 16 bites alk. várakozó sor Időszelet osztás változó prioritásokkal System VM MS-DOS VM MS-DOS VM 32 bites alkalmazások Szál1 pr=4 16 bites alkalmazások Szál3 pr=16 Szál4 pr=20 Szál5 pr=12 Szál2 pr=20 Elsõdleges scheduler 2 4 Idõszelet osztás 36

II.8. Rapid Application Development Environment Komponensalapú fejlesztés: using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text; using System.Windows.Forms; namespace WindowsFormsApplication1 { public partial class Form1 : Form { public Form1() { InitializeComponent(); private void button1_click(object sender, EventArgs e) { button1.text = "alma"; BackColor = System.Drawing.Color.Red; 37

II.9. Microsoft.Net Célok: Biztonságos programfejlesztés Több (Objektum és komponens orientált) nyelv támogatása Platform-független kialakítás Hálózati megoldások CLI Common Language Infrastructure C# Managed C++ VB.Net JScript J# Stb. CIL Common Web-szolgáltatások Létező műveletek (fájlnyitás) Web/Windows felhasználói felület Adatok, többszintű típusellenőrzésel (XML - extensible Markup Language) Alaposztályok CLR Common Language Runtime (kód futtatás virtuális gépen) Új, csak a CLR műveletek, (szemétgyűjtés) Intermediate Language CTS Common Type Strudcture JIT Just In Time fordító Operációs rendszer 38

III. Adatszerkezetek és algoritmusok 39

Bevezetés Adatszerkezet egyszerű vagy összetett alapadatok rendszerének matematikai, logikai modellje elég jó ahhoz, hogy tükrözze a valós kapcsolatokat elég egyszerű a kezeléshez Adatszerkezet típusok Tömbök lineáris egy vagy többdimenziós Kapcsolt listák a kapcsolati információ is adat Gráf adathalmaz adatpárok kapcsolattal Fa hurok nélküli gráf Verem LIFO (Last In First Out) Sor FIFO (First In First Out). Műveletek feldolgozási tevékenységek (algoritmusok) Bejárás - az elemek elérése Keresés - adott értéknek megfelelő elemek kiválasztása Beszúrás - új adat beillesztése Törlés - adatelem eltávolítása Rendezés - elemeket logikai sorrendbe Összeválogatás - különböző rendezett adathalmazokból új elemhalmaz kialakítása Bonyolultság futási idő vagy helyigény az adatok számának függvényében 40 B(n)

III.1 Lineáris tömbök N db. azonos típusú adatelem az elemekre egymást követő számokból álló indexhalmazzal hivatkozunk az elemeket egymást követő memóriahelyek tárolják az elemekhez bejárás nélkül férünk hozzá LB LB+1 UB-1 UB Lower Bound Upper Bound Hosszúság (Length) L = UB-LB+1 Indexelt alak A 1, A 2 A(1), A(2) A[1], A[2] Példa (C#) int [] DATA; DATA = new int [5]; DATA[0]=154 ; DATA[3]=-33 ; DATA[4]=1 ; 154-33 1 154. -33 1 III.1.1 Hozzáférés tömbelemhez - indexelés (C) int DATA[5]; LOC(DATA) LOC(DATA[4]) LOC(DATA[k])=LOC(DATA)+w * k ; w az alapadat tárolási mérete 41

III.1.2 Bejárás Ha L n elemű lineáris tömb, akkor minden eleme kiírható k számláló k=0 k<n hamis k=k+1 PRINT L[k] igaz Példa (C#) const int n = 6; int[] l; l = new int[n]; Random vletlen = new Random(); for (int k = 0; k < n; k++) { l[k] = vletlen.next(100); for (int k = 0; k < n; k++) { Console.WriteLine(l[k]); III.1.2.1 Pl 90 94 65 38 51 83 Példa (C) const int n = 10; int l[n]; for (int k = 0; k < n; k++) { l[k] = rand(); for (int k = 0; k < n; k++) { printf("%i\n",l[k]); 42

III.1.3 Rendezés Ha L n elemű lineáris tömb, akkor rendezett, ha L[0]< L[1]< L[2]<L[3]... L[n-1]<L[n] III.1.3.1 Buborék rendezés k, p számláló, s segéd k=0 k<n hamis k=k+1 hamis p<n-1-k igaz L[p]>L[p+1] igaz s=l[p] L(p)=L[p+1] L[p+1]=s p=p+1 hamis p=0 igaz n ( n 1 ) Bonyolultság : 2 O( n ) 2 43

Példa (C#) const int n =6; int[] l; l = new int[n]; Random vletlen=new Random(); for (int k = 0; k < n; k++) { l[k] = vletlen.next(100); for (int k = 0; k < n; k++) { for (int p=0; p<n-1-k;p++){ if (l[p] > l[p + 1]) { int s = l[p]; l[p] = l[p + 1]; l[p + 1] = s; for (int k = 0; k < n; k++) { Console.WriteLine(l[k]); Példa (C) const int n = 6; int l[n]; for (int k = 0; k < n; k++) { l[k] = rand(); for (int k = 0; k < n; k++) { for (int p=0; p<n-1-k;p++) { if (l[p] > l[p + 1]) { int s = l[p]; l[p] = l[p + 1]; l[p + 1] = s; for (int k = 0; k < n; k++) { printf("%i\n",l[k]); 44

III.1.3.2 Például 90 94 65 38 51 83 90 65 94 38 51 83 90 65 38 94 51 83 90 65 38 51 94 83 90 65 38 51 83 94 65 90 38 51 83 94 65 38 90 51 83 94 65 38 51 90 83 94 65 38 51 83 90 94 38 65 51 83 90 94 38 51 65 83 90 94 38 51 65 83 90 94 45

III.1.4 Keresés III.1.4.1 Szekvenciális keresés KER-t keressük, az n elemű L elemei között, LOC a keresett pozíció L[n]=KER K=0 L[K] KER hamis LOC=k Példa (C#) Bonyolultság : n 1 O( n ) k=k+1 const int n = 6; int[] l; l = new int[n+1]; Random vletlen = new Random(); for (int k = 0; k < n; k++) { l[k] = vletlen.next(10); Console.WriteLine("l[{0]={1", k, l[k]); int ker=5; l[n]=ker; int j = 0; while (l[j]!=ker) { j++; Console.WriteLine("Az 5 a {0.", j); III.1.4.2 Pl. 0 9 0 6 0 4 Az 5 a 6. - nincs ilyen igaz Példa (C) const int n = 10; int l[n+1]; for (int k = 0; k < n; k++) { l[k] = rand(); int ker=l[7]; l[n]=ker; int j = 0; while (l[j]!=ker) { j++; printf("az %i az %i.\n",l[7],j); 46

III.1.4.3 Bináris keresés KER-t keressük, ha L sorbarendezett, Beg, End, Mid segédváltozók, LOC a keresett pozíció, (INT) az egészrész Beg=LB(L) End=UB(L) Mid=INT((Beg+End)/2) igaz LOC=Mid End=Mid-1 igaz Beg<End és L(Mid) KER hamis L[Mid]=KER Mid=(INT)((Beg+End)/2) KER<L[Mid] igaz hamis LOC=Null Beg=Mid+1 hamis Bonyolultság : A legalább szükséges összehasonlítások száma f(n), Minden összehasonlításkor feleződik a minta f ( n ) 2 n f ( n ) log2 ( n ) 1 47

Példa (C#) const int n = 10; int[] l; l = new int[n + 1]; Random vletlen = new Random(); for (int k = 0; k < n; k++) { l[k] = vletlen.next(10); Console.WriteLine("l[{0]={1", k, l[k]); Console.WriteLine("Sorbarakva"); Array.Sort(l); for (int k = 0; k < n; k++) { Console.WriteLine("l[{0]={1", k, l[k]); int beg = 0; int end = n - 1; int mid = (int)((beg + end) / 2); int ker = 5; while ((beg<end) && (l[mid]!=ker)) { if (ker < l[mid]) end=mid-1; else beg=mid+1; mid = (int)((beg + end) / 2); if (l[mid] == ker) Console.WriteLine("Az 5 az {0.",mid); else Console.WriteLine("Nincs 5"); Példa (C) const int n = 10; int l[n+1]; for (int k = 0; k < n; k++) { l[k] = rand(); printf("%i") for (int k = 0; k < n; k++) { for (int p=0; p<n-1-k;p++) { if (l[p] > l[p + 1]) { int s = l[p]; l[p] = l[p + 1]; l[p + 1] = s; int beg = 0; int end = n - 1; int mid = (int)((beg + end) / 2); int ker = l[7]; while ((beg<end) && (l[mid]!=ker)) { if (ker < l[mid]) end=mid-1; else beg=mid+1; mid = (int)((beg + end) / 2); if (l[mid] == ker) printf("az %i az %i.",l[mid],mid); else 48 printf("nincs");

III.1.4.4 Pl. 2 4 3 2 4 7 7 2 1 2 Sorbarakva 1 2 2 2 2 3 4 4 7 7 beg=0 mid=4 end=9 beg=5 mid=7 end=9 beg=8 mid=8 end=9 Az 7 az 8. 49

III.2. Többdimenziós tömbök N * M db. azonos típusú adatelem az elemekre egymást követő számokból álló indexhalmazokból alkotott számpárokkal hivatkozunk az elemeket egymást követő memóriahelyek tárolják az elemekhez bejárás nélkül férünk hozzá III.2.1 Hozzáférés tömbelemhez - indexelés Kétdimenziós eset LB SOR1 LB SOR1 +1 UB SOR1-1 UB SOR1 LB SOR2 LB SOR2 +1 UB SOR2-1 UB SOR 2 LB SORn-1 LB SORn-1 +1 UB SORn-1-1UB SORn-1 LB SORn LB SORn +1 UB SORn -1 UB SOR n Indexelt alak A 1,1, A 12 A(1,1), A(1,2) A[1,1], A[1,2] Memória pozíció (A m * n-es mátrix) LOC(A(j,k))=LOC(A)+w * (n * j+k) ; w az alapadat tárolási mérete 50

Példa (C#) float[,] matrix; matrix = new float [3,3]; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { if (i == j) matrix[i, j] = 1; else matrix[i, j] = 0; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) Console.Write("{0,8:f2",matrix[i, j]); Console.WriteLine(); Példa (C) float matrix [3][3]; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { if (i == j) matrix[i][ j] = 1; else matrix[i][j] = 0; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) printf("%8.2f",matrix[i][j]); printf("\n"); III.2.2 Pl. 1,00 0,00 0,00 0,00 1,00 0,00 0,00 0,00 1,00 51

III.3. Rekordok, rekordszerkezetek, állományok A rekord egymáshoz tartozó (a világ egy egyedére vonatkozó) adattételek (mezők, attribútumok) gyűjteménye. az adattételek lehetnek összetettek** és tovább nem bonthatók egyszerűek*. például változó méretű adatsorok, szabálytalan tömbök tárolására használható Az állomány rekordok összessége. Név LB Lakcím** SOR1 +1 Testmagasság Testsúly* Példa (C#) struct ember { public String nev; public String lakcim; public int testmagassag; public int testsuly; // ember x; x = new ember(); x.nev = "Lajos"; x.lakcim = "Budapest"; x.testmagassag = 160; x.testsuly = 50; Console.WriteLine(x.nev + " " + x.lakcim + " " + x.testmagassag + " " + x.testsuly); Console.ReadLine(); LB SOR1 #include <stdio.h> #include <conio.h> #include <string.h> int _tmain(int argc, _TCHAR* argv[]) { struct ember { char nev[64]; char lakcim[64]; int testmagassag; int testsuly; ; // ember x; strcpy(x.nev,"lajos"); strcpy(x.lakcim,"budapest"); x.testmagassag = 160; x.testsuly = 50; printf("%s ",x.nev); printf("%s ",x.lakcim); printf("%i ",x.testmagassag); printf("%i \n",x.testsuly); getch(); return 0; Példa (C) 52

III.3.1 Szintszám, minősítés Az adattételek lehetnek összetettek, altételekkel. Például: Gyermek Név Apa Anya Példa (C#) struct ember { public string nev; public int apa; public int anya; static void Main(string[] args) { ember[] x; x = new ember[5]; x[0].nev = "Ádám"; x[1].nev = "Éva"; x[2].nev = "Káin"; x[2].apa = 0; // tömbindex a pointer helyett x[2].anya = 1; Console.ReadLine(); Név Példa (C) struct ember { char nev[64]; int apa; int anya; ; ember x[5]; strcpy(x[0].nev,"ádám"); strcpy(x[1].nev, "Éva"); strcpy(x[2].nev, "Káin"); x[2].apa = 0; // tömbindex a pointer helyett x[2].anya = 1; Név 53

III.4. Kapcsolt listák A kapcsolt lista vagy egyirányú lista adatelemek, vagy csomópontok lineáris gyűjteménye, ahol az elemek sorrendjét mutatók rögzítik. Start a mutatókat tároló elemet kapcsolómezőnek hívjuk. x III.4.1 Kapcsolt listák a memóriában Minden csomóponthoz egy tömbelemet (INFO(k) az indexelt csomópont), Minden követőhöz egy másik tömbelemet (LINK(k)) rendelünk. Start INFO (0,0) (100,100) (100,0) (0,100) (0,0) LINK 3 4 2 5 x III.4.2 Kapcsolt listák bejárása A PTR mutató az éppen feldolgozott csomópontra mutat. A kezdetet a START mutató jelöli. A vége NULL Hasonló a lineáris tömbhöz. 54

III.4.3 Példa Mutató aritmetika, csoport elemeinek bejárása Ha P változó mutató, akkor a P+1 kifejezés a következő memóriacímet jelenti Példa (C#) /unsafe (Property/Build/Allow unsafe code) const int n=10; P=C k int[] l; l = new int[n]; Random vletlen= new Random(); for (int k = 0; k < n; k++) { l[k] = vletlen.next(10); Console.WriteLine("l[{0]={1", k, l[k]); Console.WriteLine(); unsafe { int i=4; fixed ( int * ipk=&l[i]) { fixed ( int * ipv=&l[8]) { int * ip = ipk; while (ip < ipv) { Console.WriteLine( "l[{0]={1", i++, *ip++); P=P+1 Bejárás P<C v igaz hamis const int n=10; Példa (C) int l[n]; for (int k = 0; k < n; k++) { l[k] = 10*(float)rand()/RAND_MAX; printf("l[%2i]=%3i\n", k, l[k]); printf("\n"); int i=4; int * ipk=&l[i]; int * ipv=&l[8]; int * ip = ipk; while (ip < ipv) { printf("l[%2i]=%2i ", i++, *ip++); 55

III.4.4 Példa Csoport elemeinek bejárása tömbelemmutatóval PTR=START PTR NULL Példa (C#) const int n=10; int[,] l; l = new int[n,3]; // [x,y,következő] Random vletlen= new Random(); int start=0; for (int k = 0; k < n; k++) { l[k,0] = vletlen.next(10); l[k,1] = vletlen.next(10); if (k==n-1) l[k, 2] = -1; else l[k, 2] = k+1; Console.WriteLine( "l[{0,1]={1 l[{0,2]={2", k,l[k, 0],l[k, 1]); Console.WriteLine(); int akt=start; // bejárás while (true) { Console.WriteLine( "l[{0,1]={1 l[{0,2]={2", akt,l[akt,0],l[akt, 1]); if (l[akt, 2] == -1) break; akt = (int)l[akt, 2]; PTR=LINK(PTR) {PTR INFO feldolgozás igaz hamis const int n=10; int l[n][3]; Példa (C) // [x,y,következő] int start=0; for (int k = 0; k < n; k++) { l[k][0] = 10*(float)rand()/RAND_MAX; l[k][1] = 10*(float)rand()/RAND_MAX;; if (k==n-1) l[k][2] = -1; else l[k][2] = k+1; printf("l[%1i,1]=%2i l[%1i,2]=%2i\n", k,l[k][0],l[k][1]); printf("\n"); int akt=start; // bejárás while (true) { printf("l[%1i,1]=%2i l[%1i,2]=%2i\n", akt,l[akt][0],l[akt][1]); if (l[akt][2] == -1) break; akt = (int)l[akt][2]; 56

l[0,1]=7 l[0,2]=3 következő=l[0,3]=1 l[1,1]=3 l[1,2]=4 következő=l[1,3]=2 l[2,1]=1 l[2,2]=0 következő=l[2,3]=3 l[3,1]=0 l[3,2]=6 következő=l[3,3]=4 l[4,1]=6 l[4,2]=0 következő=l[4,3]=5 l[5,1]=4 l[5,2]=0 következő=l[5,3]=6 l[6,1]=6 l[6,2]=1 következő=l[6,3]=7 l[7,1]=0 l[7,2]=6 következő=l[7,3]=8 l[8,1]=3 l[8,2]=7 következő=l[8,3]=9 l[9,1]=0 l[9,2]=9 következő=l[9,3]=-1 l[0,1]=7 l[0,2]=3 következő=l[0,3]=1 l[1,1]=3 l[1,2]=4 következő=l[1,3]=2 l[2,1]=1 l[2,2]=0 következő=l[2,3]=3 l[3,1]=0 l[3,2]=6 következő=l[3,3]=4 l[4,1]=6 l[4,2]=0 következő=l[4,3]=5 l[5,1]=4 l[5,2]=0 következő=l[5,3]=6 l[6,1]=6 l[6,2]=1 következő=l[6,3]=7 l[7,1]=0 l[7,2]=6 következő=l[7,3]=8 l[8,1]=3 l[8,2]=7 következő=l[8,3]=9 l[9,1]=0 l[9,2]=9 következő=l[9,3]=-1 57

III.4.5 Keresés kapcsolt listában (tömbös) Ugyanaz mint lineáris esetben, csak az összehasonlítás és a léptetés elválik PTR=START Példa (C#) LOC= {PTR PTR=LINK(PTR) const int n = 10; int[,] l; l = new int[n, 2]; //szam,következő Random vletlen = new Random(); int start = 0; for (int k = 0; k < n; k++) { l[k, 0] = vletlen.next(10); if (k == n - 1) l[k, 1] = -1; else l[k, 1] = k + 1; Console.WriteLine( "l[{0,0]={1 következő {2", k,l[k,0],l[k,1]); int keres = l[4, 1]; Console.WriteLine("A keresett={0", keres); Console.WriteLine(); // kereses int akt = start; while (l[akt,1]!=-1) { if (keres == l[akt, 0]) Console.WriteLine("l[{0,1]={1", akt, l[akt, 0]); akt = (int)l[akt, 1]; igaz KER= {PTR INFO hamis PTR NULL igaz hamis const int n = 10; int l[n][2]; Példa (C) //szam,következő int start = 0; for (int k = 0; k < n; k++) { l[k][0] = 10*(float)rand()/RAND_MAX; if (k == n - 1) l[k][1] = -1; else l[k][1] = k + 1; printf( "l[%1i,0]=%2i kovetkezo %2i\n", k,l[k][0],l[k][1]); int keres = l[4][1]; printf("a keresett=%2i", keres); printf("\n"); // kereses int akt = start; while (l[akt][1]!=-1) { if (keres == l[akt][ 0]) printf("l[%1i,1]=%2i ", akt, l[akt][0]); 58 akt = (int)l[akt][1];

III.4.6 Beszúrás kapcsolt listába (tömbök) Start x Start élda (C#) x const int n = 11; int[,] l; l = new int[n + 1, 3]; //x,y,következő Random vletlen = new Random(); int start = 0; for (int k = 0; k < n; k++) { l[k, 0] = vletlen.next(10); l[k, 1] = vletlen.next(10); if (k == n - 1) l[k, 2] = -1; else l[k, 2] = k + 1; Console.WriteLine( "l[{0,1]={1 l[{0,2]={2", k, l[k, 0], l[k, 1]); int akt = start; // beszúrás while (akt!=2) { akt = (int)l[akt, 2]; l[n, 2] = l[akt, 2]; l[akt, 2] = n ; l[n, 0] = 1000; l[n, 1] = 1000; int j = 0; do { Console.WriteLine("l[{0,1]={1 l[{0,2]={2", j, l[j, 0], l[j, 1]); j = l[j, 2]; while (l[j, 2]!= -1); Példa (C) const int n = 11; int l[n + 1][ 3]; //x,y,következő int start = 0; for (int k = 0; k < n; k++) { l[k][0] = 10*(float)rand()/RAND_MAX; l[k][1] = 10*(float)rand()/RAND_MAX;; if (k == n - 1) l[k][2] = -1; else l[k][2] = k + 1; printf("l[%i,1]=%i l[%i,2]=%i\n", k, l[k][0], k, l[k][1]); int akt = start; // beszúrás while (akt!=2) { akt = (int)l[akt][2]; l[n][2] = l[akt][2]; l[akt][2] = n ; l[n][0] = 1000; l[n][1] = 1000; int j = 0; do { printf("l[%i,1]=%i l[%i,2]=%i\n", j, l[j][0], j, l[j][1]); j = l[j][2]; while (l[j][2]!= -1); 59

l[0,1]=9 l[0,2]=9 l[0,3]=1 l[1,1]=6 l[1,2]=9 l[1,3]=2 l[2,1]=8 l[2,2]=0 l[2,3]=3 l[3,1]=2 l[3,2]=1 l[3,3]=4 l[4,1]=5 l[4,2]=8 l[4,3]=5 l[5,1]=6 l[5,2]=8 l[5,3]=6 l[6,1]=2 l[6,2]=5 l[6,3]=7 l[7,1]=4 l[7,2]=4 l[7,3]=8 l[8,1]=9 l[8,2]=5 l[8,3]=9 l[9,1]=6 l[9,2]=6 l[9,3]=-1 Beszúrás l[2,2]=10 l[10,1]=1000 l[10,2]=1000 l[10,3]=3 Lista l[0,1]=9 l[0,2]=9 l[0,3]=1 l[1,1]=6 l[1,2]=9 l[1,3]=2 l[2,1]=8 l[2,2]=0 l[2,3]=10 l[3,1]=2 l[3,2]=1 l[3,3]=4 l[4,1]=5 l[4,2]=8 l[4,3]=5 l[5,1]=6 l[5,2]=8 l[5,3]=6 l[6,1]=2 l[6,2]=5 l[6,3]=7 l[7,1]=4 l[7,2]=4 l[7,3]=8 l[8,1]=9 l[8,2]=5 l[8,3]=9 l[9,1]=6 l[9,2]=6 l[9,3]=-1 l[10,1]=1000 l[10,2]=1000 l[10,3]=3 Bejárás l[0,1]=9 l[0,2]=9 l[0,3]=1 l[1,1]=6 l[1,2]=9 l[1,3]=2 l[2,1]=8 l[2,2]=0 l[2,3]=10 l[10,1]=1000 l[10,2]=1000 l[10,3]=3 l[3,1]=2 l[3,2]=1 l[3,3]=4 l[4,1]=5 l[4,2]=8 l[4,3]=5 l[5,1]=6 l[5,2]=8 l[5,3]=6 l[6,1]=2 l[6,2]=5 l[6,3]=7 l[7,1]=4 l[7,2]=4 l[7,3]=8 l[8,1]=9 l[8,2]=5 l[8,3]=9 60

III.4.7 Törlés kapcsolt listából Start x Start x III.4.8 Kétirányú listák Minden irányban bejárható Első INFO x INFO INFO INFO x III.4.9 Beszúrás kétirányú listába Első INFO x INFO INFO INFO x Utolsó Utolsó INFO III.4.10 Törlés kétirányú listából Első INFO x INFO INFO INFO x Utolsó 61

l[0,1]=4 l[0,2]=4 következő=l[0,3]=1 l[1,1]=1 l[1,2]=1 következő=l[1,3]=2 l[2,1]=6 l[2,2]=3 következő=l[2,3]=3 l[3,1]=7 l[3,2]=9 következő=l[3,3]=4 l[4,1]=5 l[4,2]=5 következő=l[4,3]=5 l[5,1]=5 l[5,2]=2 következő=l[5,3]=6 l[6,1]=1 l[6,2]=8 következő=l[6,3]=7 l[7,1]=8 l[7,2]=1 következő=l[7,3]=8 l[8,1]=7 l[8,2]=7 következő=l[8,3]=9 l[9,1]=9 l[9,2]=3 következő=l[9,3]=-1 A 4-e elem törlése l[0,1]=4 l[0,2]=4 következő=l[0,3]=1 l[1,1]=1 l[1,2]=1 következő=l[1,3]=2 l[2,1]=6 l[2,2]=3 következő=l[2,3]=3 l[3,1]=7 l[3,2]=9 következő=l[3,3]=5 l[4,1]=5 l[4,2]=5 következő=l[4,3]=5 l[5,1]=5 l[5,2]=2 következő=l[5,3]=6 l[6,1]=1 l[6,2]=8 következő=l[6,3]=7 l[7,1]=8 l[7,2]=1 következő=l[7,3]=8 l[8,1]=7 l[8,2]=7 következő=l[8,3]=9 l[9,1]=9 l[9,2]=3 következő=l[9,3]=-1 Bejárás l[0,1]=4 l[0,2]=4 következő=l[0,3]=1 l[1,1]=1 l[1,2]=1 következő=l[1,3]=2 l[2,1]=6 l[2,2]=3 következő=l[2,3]=3 l[3,1]=7 l[3,2]=9 következő=l[3,3]=5 l[5,1]=5 l[5,2]=2 következő=l[5,3]=6 l[6,1]=1 l[6,2]=8 következő=l[6,3]=7 l[7,1]=8 l[7,2]=1 következő=l[7,3]=8 l[8,1]=7 l[8,2]=7 következő=l[8,3]=9 l[9,1]=9 l[9,2]=3 következő=l[9,3]=-1 62

III.5. Verem (Stack) Last In First Out Új elem behelyezése (PUSH) a tetejére (TOP) Elem leemelése (POP) III.5.1 A verem tárolása a b c d III.5.1.1 PUSH igaz TOP TOP=TOP+1 STACK(TOP)=Elem maxstk TOP<MAXSTK III.5.1.2 POP hamis hamis túlcsordul Elem=STACK(TOP) TOP=TOP-1 TOP=0 igaz alulcsordul 63

public class stack { public const int max_stack = 10; public int stack_pointer = 0; public double[] x; public stack() { x = new double[max_stack]; public void push(double be) { if (stack_pointer < max_stack) x[stack_pointer++] = be; public double pop() { return x[--stack_pointer]; stack s = new stack(); Console.WriteLine("Először bekerül a 13"); s.push(13); Console.WriteLine("Utána bekerül a 14"); s.push(14); Console.WriteLine("Először a {0 jön ki", s.pop()); Console.WriteLine("Aztán a {0 jön ki", s.pop()); 64

Példa C++ class stack { public: static const int max_stack = 10; int stack_pointer; double * x; stack() { x = new double[max_stack]; stack_pointer=0; void push(double be) { if (stack_pointer < max_stack) x[stack_pointer++] = be; double pop() { return x[--stack_pointer]; ; //Verem létrehozása stack * s=new stack(); printf("eloszor bekerul a 13\n"); s->push(13); printf("utana bekerul a 14\n"); s->push(14); printf("eloszor a %f jon ki\n", s->pop()); printf("aztan a %f jon ki\n", s->pop()); 65

III.5.2 Rekurzió III.5.2.1. Faktoriális iteratív definíció n!=1 2 3 (n-2) (n-1) n N=0 hamis Fakt=1 k=1 k<=n k=k+1 Fakt=Fakt*k igaz hamis III.5.2.2. Faktoriális rekurzív definíció 0!=1 ; n!=n (n-1)! hamis N=0 igaz igaz Fakt=1 Fakt()=n * Fakt(n-1) Fakt()=1 A verem és az alprogram kapcsolata Példa (C#) public class Szamitasok { public static int fakt(int n) { if (n<2) return 1; else return n*fakt(n-1); Console.Write("Nem negatív egész="); int n=convert.toint32(console.readline()); Console.WriteLine("{0!={1",n, Szamitasok.fakt(n)); 66

III.6. Sor (Queue) First In First Out III.6.1 A sor tárolása (lebegő sor) a BOT b c d TOP maxque III.6.1.1 PUSH igaz TOP=TOP+1 QUE(TOP)=Elem TOP<MAXQUE-1 III.6.1.2 POP hamis túlcsordul hamis Elem=QUE(BOT) BOT=BOT+1 BOT>TOP igaz üres 67

public class queue { public const int size = 10; public int max_queue = 0; public int min_queue = 0; public double[] x; public queue() { x = new double[size]; public void push(double be) { if (max_queue< size -1) x[max_queue++] = be; public double pop() { if (min_queue < max_queue) return x[min_queue++]; else return 99999; //Sor létrehozása queue q = new queue(); Console.WriteLine("Először bekerül a 13"); q.push(13); Console.WriteLine("Utána bekerül a 14"); q.push(14); Console.WriteLine("Először a {0 jön ki", q.pop()); Console.WriteLine("Aztán a {0 jön ki", q.pop()); #include "stdafx.h" #include <conio.h> #include <stdlib.h> class queue { public: static const int size = 10; int max_queue; int min_queue; double x[size]; queue() { max_queue=0; min_queue=0; void push(double be) { if (max_queue< size -1) x[max_queue++] = be; double pop() { if (min_queue < max_queue) return x[min_queue++]; else return 99999; ; Példa (C) int _tmain(int argc, _TCHAR* argv[]) {//Sor létrehozása queue q = queue(); printf("eloszor bekerul a 13.0\n"); q.push(13); printf("utana bekerul a 14.0\n"); q.push(14); printf("eloszor a %f jon ki\n", q.pop()); printf("aztan a %f jon ki\n", q.pop()); getch(); 68 return 0;

III.7. Bináris fa Elemek véges halmaza, amely vagy üres vagy egyetlen T elemhez (gyökér) kapcsolt két diszjunkt T1 ésd T2 részfa alkotja A H D B C E F G I K J A gyökér (szülő, apa) R(A) - jobboldali részfa (C,F,G, I, J, K) L(A) baloldali részfa (B, D, E, H) C A jobboldali szukcesszora (gyermek, leszármazott) B A baloldali szukcesszora Minden csomópontnak 0, 1, illetve 2 szukcesszora lehet Zárócsomópont - 0 szukcesszor Az összekötő vonalak - élek, 0 szukcesszor - levél utolsó él - ág Szintszám : gyökér - 0 leszármazott - szülő+1 Generáció : azonos szintszámú elemek Mélység : az azonos ágon elhelyezkedő elemek maximális száma Teljes : az utolsó szintet kivéve a csp-k száma maximális 69 Kiterjesztett bináris fa minden csomópontnak 0/2 gyermeke van

III.7.1 Bináris fák ábrázolása kapcsolt szerkezettel Root A B C D x x E x x F x G x H x x I x J x III.7.2 Bináris fák ábrázolása tömbökkel x K x Root 1 2 3 4 5 6 7 8 9 10 11 12 13 Avail L(Root) R(Root) A C G J K F I B D H E 10 7 8 5 0 0 0 11 12 0 0 2 3 4 0 0 0 0 13 0 0 0 70

III.7.3 Bináris fák szekvenciális ábrázolása a gyökér T(1) ha egy csomópont a T(k)-n van, akkor ha van L(T(k))=T(2*k) egyébként NULL akkor ha van R(T(k))=T(2*k+1) egyébként NULL A B C D E F G 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A B C D E F G NULL NULL NULL NULL NULL NULL NULL NULL III.7.4 Bináris fák bejárása Több lehetőség. Pl. a G gyökér Az L(G) bejárása az irányítás szerint, Az R(G) bejárása az irányítás szerint, D B A C E F G H I J K 71

III.7.4.1. Pl. az irányítással megegyező bejárás (I.8.1 tárolás) NULL a STACK-en PTR a gyökéren Ameddig a PTR!=NULL az összes L() feldolgozása az összes R() a STACK-re PTR=L(PTR) léptetés utána PTR=STACK legfelső elemével (ha nem NULL, R feldolgozás) TOP=0 STACK(TOP)=NULL PTR=Gyökér PTR NULL hamis STACK(TOP)=R(PTR) TOP=TOP+1 igaz igaz hamis R(PTR) NULL ADAT(PTR) feldolgozás A PTR=L(PTR) igaz B C D E F G L(PTR) NULL H I J TOP=TOP-1 PTR=STACK(TOP) hamis K 72

III.8. Általános fa Elemek véges halmaza (T), amely Tartalmaz egy kitüntetett R gyökérelemet A többi elem nem nulla diszjunkt részfája T-nek A B C D E F G H I J K L III.8.1 Tárolás számítógépen INFO(k) - az elem adatai GYERMEK(k) - az első gyermek TESTVÉR(k) - az első testvér 1 2 3 4 5 6 7 8 9 10 11 12 13 INFO A B C D E F G H I J K L TESTVÉR GYERMEK 0 3 5 0 7 8 0 10 0 12 13 0 2 6 0 9 11 0 0 0 0 0 0 0 73

III.9 Gráf Két halmazzal jellemezhető adatszerkezet Csomópontok sorszámozott halmaza (csúcsok) Az elemeket összekötő e=[u,v] számpárral jellemzett élek halmaza az összekötött csomópontokat szomszédoknak hívjuk deg(u) a csomópont foka, a befutó élek száma deg(u)=0 izolált csomópont v 0 -ból v n -be haladó élek halmazát P(v 0, v 1, v 0 ) útnak nevezzük. P út zárt, ha v 0 =v n P út egyszerű, ha minden pontja különböző Kör a 3-nál hosszabb egyszerű zárt út. Összefüggő egy gráf, ha bármely két pontja között létezik út. Egy G gráf akkor és csak akkor összefüggő, ha bármely két pontja között létezik egyszerű út. Egy gráf teljes, ha minden csomópontja minden csomópontjával össze van kötve. A fa köröket nem tartalmazó összefüggő gráf G gráf címkézett, ha éleihez adatokat rendelünk. Ha G gráf éleihez rendelt adatok nem negatívak, akkor a gráfot súlyozottnak hívjuk. G gráf irányított, ha az éleknek irányítottságuk van 74

III.9.1 Szekvenciális tárolás számítógépen Szomszédsági mátrix a i,j =1 ha i-ből j felé halad él a i,j =0 egyébként C A B A A B C D A 0 1 1 0 B 0 0 0 0 C 0 0 0 1 D D 0 0 0 0 Ha A a G gráf szomszédsági mátrixa, akkor A k mátrix i,j. eleme az i-ből j-be vezető K hosszú utak számát adja. A 2 A B C D A 0 0 0 1 Útmátrix p i,j =1 ha i-ből j felé halad valamilyen út p i,j =0 - egyébként B 0 0 0 0 C 0 0 0 0 D 0 0 0 0 U A B C D A 0 1 1 1 B 0 0 0 0 C 0 0 0 1 D 0 0 0 0 Egy m pontból álló irányított gráf útmátrixának p ij tagja akkor és csak akkor 1, ha Az A szomszédsági mátrixból képzett A+A 2 +.+A m mátrix i,j. eleme nem 0. 75

III.10. Alkalmazások III.10.1. Bejárás négyzetszámok összege szorzata Feltöltés k=0 k<=n hamis k=k+1 L[k]=k 2 igaz Számítás sz=0 p=1 k=0 k<=n hamis k=k+1 igaz int n=10; int[] L = new int [n+1]; for (int k=0; k<=n; k++) { L[k]=k*k; int sz=0; int p=1; for (int k=0; k<=n; k++) { sz+=l[k]; p*=l[k]; sz+=k 2 p * =k 2 const int n=10; int L[n+1]; for (int k=0; k<=n; k++) { L[k]=k*k; int sz=0; int p=1; for (int k=0; k<=n; k++) { sz+=l[k]; p*=l[k]; 76

III.10.2. Bejárás - numerikus integrálás, deriválás Numerikus derivált f x = f n f n 1 x n x n 1 h = x n x n 1 df(x) dx f n f n 1 h x + y n 1 Numerikus integrál (trapéz szabály) h (f i 1 + f i ) 2 f n 1 x n 1 x n f n Feltöltés k=0 k<=n hamis k=k+1 f[k]=x[k] 2-0.25 x[k]=k*0.1 igaz 77

Számítás derivált és integrál integ=0 k=1 k<=n hamis k=k+0.1 igaz integ += f k 1 + f[k] 2 (x k x k 1 ) d[k] = f k + f[k 1] x k x k 1 double[] f = new double[n + 1]; double[] x = new double[n + 1]; double[] d = new double[n + 1]; double dt=0.1; for (int k = 0; k <= n; k++) { x[k] = k * dt; f[k] = x[k] * x[k] - 0.25; double integ = 0; for (int k = 1; k <= n; k++) { integ += (f[k - 1] + f[k]) / 2 * (x[k] - x[k - 1]); d[k] = (f[k] + f[k - 1]) / (x[k] - x[k - 1]); double f[n + 1]; double x[n + 1]; double d[n + 1]; double dt=0.1; for (int k = 0; k <= n; k++) { x[k] = k * dt; f[k] = x[k] * x[k] - 0.25; double integ = 0; for (int k = 1; k <= n; k++) { integ += (f[k - 1] + f[k]) / 2 * (x[k] - x[k - 1]); d[k] = (f[k] + f[k - 1]) / (x[k] - x[k - 1]); 78

III.10.3. Gyökkeresés Gyökkeresés bejárással gyok=-1 k=0 k<=n hamis k=k+1 gyok = x k + x[k 1] 2 dt igaz igaz f k f k 1 0 hamis double gyok = -1; for (int k = 1; k <= n; k++) { if (f[k - 1] * f[k]<=0) gyok = dt*(x[k] + x[k - 1])/2; double gyok = -1; for (int k = 1; k <= n; k++) { if (f[k - 1] * f[k]<=0) gyok = dt*(x[k] + x[k - 1])/2; 79

Bináris gyökkeresés B=0 V=n V B < ε igaz gyok=k*dt V=K B=K igaz F[B] *f[k] <0 hamis K= V+B 2 hamis int K; int B=0; int V=n; while (V-B>=1) { K = (B + V) / 2; if (f[b] * f[k] < 0) V = K; else { if (f[k]!=0) B = K; else B=V=K; double gyok=k*dt; int K; int B=0; int V=n; while (V-B>1) { K = (B + V) / 2; if (f[b] * f[k] < 0) V = K; else { if (f[k]!=0) B = K; else B=V=K; double gyok=k*dt; 80