Tamás Péter (D. 424) Mechatronika, Optika és Gépészeti Informatika Tanszék (D 407)
|
|
- Zita Orsós
- 5 évvel ezelőtt
- Látták:
Átírás
1 Tamás Péter (D. 424) Mechatronika, Optika és Gépészeti Informatika Tanszék (D 407) 1
2 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
3 I. Bevezetés az informatikába 3
4 I.1 A számítógép működése I.2 Adatok I.3 Program I.4 Adatok + Program = Objektum 4
5 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 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
6 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 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
7 I.1.6 ADAT+PROGRAM I 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 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
8 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 Elemi adatok I 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 = az egyes komplemens kettes komplemens = egyes komplemens = = = = elég csak összeadni
9 Hexadecimális számok F FF Valós számok lebegőpontos X = E M*A K M Mantissza E Előjel K Karakterisztika I 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 String karaktersorozat Szövegek Vége jel C ALMA - Pascal Hossz 9
10 I.2.2 Összetett adatok I Rekord logikailag összefüggő (nem azonos típusú) elemi adatok halmaza egyszerű mező+egyszerű mező+ I File pl. logikailag összefüggő rekordok halmaza I 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
11 I.2.3 Grafikus adatok I Vektoros grafika CDR I Raszteres grafika BMP DIB JPG I Meta grafika Pl. a True Type WYSWYG WMF, EMF 11
12 I.2.4 Geometriai modell adatok I Pont I Él I Felület 7 Sorszám x-koordináta y-koordináta z-koordináta Következő csúcs Sorszám Él egyenlete 6 kezdőpont 40.0 végpont 0.0 Következő 20.0 él L L // nincs 3 L Sorszám Felület 4 egyenlete Határélek L4 Következő 4 felület F1 L5 1,2,3, F2 L6 9,10,11, Sorszám 7 Felület F3 egyenlete L74,5,8,12 Határélek n x n x 2 n x Következő felület F4 L8 8,9,10,11 F1 41,2,3, ,23 12, F5 L92,6,7,10 F2 9,10,11, ,56 45, F6 L10 3,7, 8,11 F3 4,5,8, // nincs 7 7,89 78, L11 F4 8,9,10, ,87 98, L12 F5 2,6,7, ,54 65,4 0 // nincs I Boundary REPresentation 6 F6 3,7, 8,11 3,21 32, // nincs 12
13 I CSG Név X1 Y1 Z1 X2 Y2 Z2 T Név X1 Y1 Z1 X2 Y2 Z2 T Név C1 Jellemzés T1 T2 \ Név X1 Y1 Z1 X2 Y2 Z2 R H Név C2 Jellemzés C1\H1 Mindegyik bitsor! Hogyan értelmezzük 13
14 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 Rákövetkezés (konkatenáció) I Választás (alternáció) i p h I Ciklus (iteráció) i/h i/h p h/i p h/i 14
15 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
16 I.4.2. Industry
17 II. Programozási technológiák 17
18 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
19 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 / byte ushort / short / byte uint, int / byte Logikai típus bool false..true true, false 1 byte Lebegőpontos (valós) típus float byte double ± ± , 2.1e6, 3.4F, 4.2L 8 byte decimal (-7.9 x x ) / ( ) 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
20 II.3.2 Alap algoritmus elemek II Rákövetkezés (konkatenáció) int i = 3; int j = 4; int k = i + j; II Választás (alternáció) if (i > j) { k = i - j; else { k = j - i; II Ciklus (iteráció) i = 0; k = 0; while (i < 10) { k += i++; p i h p i/h h/i 21
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
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
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
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
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
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
27 // 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
28 // 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
29 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
30 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
31 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
32 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
33 III. Adatszerkezetek és algoritmusok 39
34 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)
35 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 ; 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
36 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 Pl 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
37 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 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
38 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
39 III Például
40 III.1.4 Keresés III 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 Pl 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
41 III 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
42 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");
43 III Pl Sorbarakva beg=0 mid=4 end=9 beg=5 mid=7 end=9 beg=8 mid=8 end=9 Az 7 az 8. 49
44 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
45 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
46 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
47 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
48 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 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
49 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
50 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
51 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
52 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];
53 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
54 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
55 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
56 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
57 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 PUSH igaz TOP TOP=TOP+1 STACK(TOP)=Elem maxstk TOP<MAXSTK III POP hamis hamis túlcsordul Elem=STACK(TOP) TOP=TOP-1 TOP=0 igaz alulcsordul 63
58 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
59 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
60 III.5.2 Rekurzió III 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 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
61 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 PUSH igaz TOP=TOP+1 QUE(TOP)=Elem TOP<MAXQUE-1 III POP hamis túlcsordul hamis Elem=QUE(BOT) BOT=BOT+1 BOT>TOP igaz üres 67
62 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;
63 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
64 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 Avail L(Root) R(Root) A C G J K F I B D H E
65 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 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
66 III 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
67 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 INFO A B C D E F G H I J K L TESTVÉR GYERMEK
68 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
69 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 B C D D 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 Útmátrix p i,j =1 ha i-ből j felé halad valamilyen út p i,j =0 - egyébként B C D U A B C D A B C D 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
70 III.10. Alkalmazások III 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
71 III 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] x[k]=k*0.1 igaz 77
72 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] ; 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] ; 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
73 III 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
74 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
Adatszerkezetek és algoritmusok
Adatszerkezetek és algoritmusok 1 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ű
RészletesebbenIII. Adatszerkezetek és algoritmusok
III. Adatszerkezetek és algoritmusok 1 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ű
RészletesebbenII. Programozási technológiák
II. Programozási technológiák 1 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]
RészletesebbenIII. Adatszerkezetek és algoritmusok
III. Adatszerkezetek és algoritmusok 40 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ű
RészletesebbenTamá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
RészletesebbenTamá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ások 1. Bevezetés 2. Adatszerkezetek, algoritmusok 3. Számítástudomány alapjai 4. Számítógépek felépítése, hardware
RészletesebbenAdatszerkezetek Bevezetés Adatszerkezet Adatszerkezet típusok Műveletek Bonyolultság
datszerkezetek Bevezetés datszerkezet adatok rendszerének matematikai, logikai modellje elég jó ahhoz, hogy tükrözze a valós kapcsolatokat elég egyszerű a kezeléshez datszerkezet típusok Tömbök lineáris
RészletesebbenTamá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
RészletesebbenTamá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) 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
RészletesebbenTamá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 Kérdőív Tematika A számítógép működése Adatok Program Objektum 2 Kérdőív Kitöltötte 204 fő Felkészültség 28% 39% alap
RészletesebbenElemi adatszerkezetek
2017/12/16 17:22 1/18 Elemi adatszerkezetek < Programozás Elemi adatszerkezetek Szerző: Sallai András Copyright Sallai András, 2011, 2014 Licenc: GNU Free Documentation License 1.3 Web: http://szit.hu
RészletesebbenC# nyelv alapjai. Krizsán Zoltán 1. Objektumorientált programozás C# alapokon tananyag. Általános Informatikai Tanszék Miskolci Egyetem
C# nyelv alapjai Krizsán Zoltán 1 Általános Informatikai Tanszék Miskolci Egyetem Objektumorientált programozás C# alapokon tananyag Tartalom Bevezetés Lokális változó Utasítások Szójáték Why do all real
RészletesebbenA C# PROGRAMOZÁSI NYELV
A C# PROGRAMOZÁSI NYELV 2010.02.23. Bevezetés C# nyelv jellemzői 2 Kis és NAGY betű érzékeny Minden utasítást pontos vessző zár. Utasítás zárójel a:,. .NET Framework keretrendszerek 3 Microsoft.NET Framework
Részletesebben1. Mi a fejállományok szerepe C és C++ nyelvben és hogyan használjuk őket? 2. Milyen alapvető változókat használhatunk a C és C++ nyelvben?
1. Mi a fejállományok szerepe C és C++ nyelvben és hogyan használjuk őket? 2. Milyen alapvető változókat használhatunk a C és C++ nyelvben? 3. Ismertesse a névtér fogalmát! 4. Mit értünk a "változó hatóköre"
RészletesebbenKészítette: Nagy Tibor István
Készítette: Nagy Tibor István A változó Egy memóriában elhelyezkedő rekesz Egy értéket tárol Van azonosítója (vagyis neve) Van típusa (milyen értéket tárolhat) Az értéke értékadással módosítható Az értéke
RészletesebbenProgramozás BMEKOKAA146. Dr. Bécsi Tamás 1. Előadás
Programozás BMEKOKAA146 Dr. Bécsi Tamás 1. Előadás Bemutatkozás Előadó: Dr. Bécsi Tamás St.106, (1)463-1044, becsi.tamas@mail.bme.hu Közlekedés-, és Járműirányítási Tanszék www.kjit.bme.hu Programozás
RészletesebbenINFORMATIKAI ALAPISMERETEK
Informatikai alapismeretek középszint 1021 ÉRETTSÉGI VIZSGA 2011. május 13. INFORMATIKAI ALAPISMERETEK KÖZÉPSZINTŰ ÍRÁSBELI ÉRETTSÉGI VIZSGA JAVÍTÁSI-ÉRTÉKELÉSI ÚTMUTATÓ NEMZETI ERŐFORRÁS MINISZTÉRIUM
RészletesebbenSzámítástechnika I. BMEKOKAA152 BMEKOKAA119 Infokommunikáció I. BMEKOKAA606. Dr. Bécsi Tamás
Számítástechnika I. BMEKOKAA152 BMEKOKAA119 Infokommunikáció I. BMEKOKAA606 Dr. Bécsi Tamás Bemutatkozás Előadó: Dr. Bécsi Tamás St.106, (1)463-1044, becsi.tamas@mail.bme.hu Közlekedés-, és Járműirányítási
RészletesebbenJava II. I A Java programozási nyelv alapelemei
Java II. I A Java programozási nyelv alapelemei Miskolci Egyetem Általános Informatikai Tanszék Utolsó módosítás: 2008. 02. 19. Java II.: Alapelemek JAVA2 / 1 A Java formalizmusa A C, illetve az annak
RészletesebbenA C# programozási nyelv alapjai
A C# programozási nyelv alapjai Tisztán objektum-orientált Kis- és nagybetűket megkülönbözteti Ötvözi a C++, Delphi, Java programozási nyelvek pozitívumait.net futtatókörnyezet Visual Studio fejlesztőkörnyezet
Részletesebben5-6. ea Created by mrjrm & Pogácsa, frissítette: Félix
2. Adattípusonként különböző regisztertér Célja: az adatfeldolgozás gyorsítása - különös tekintettel a lebegőpontos adatábrázolásra. Szorzás esetén karakterisztika összeadódik, mantissza összeszorzódik.
RészletesebbenA programozás alapjai előadás. [<struktúra változó azonosítók>] ; Dinamikus adatszerkezetek:
A programozás alapjai 1 Dinamikus adatszerkezetek:. előadás Híradástechnikai Tanszék Dinamikus adatszerkezetek: Adott építőelemekből, adott szabályok szerint felépített, de nem rögzített méretű adatszerkezetek.
Részletesebben3. Határozza meg és írja ki a minta szerint, hogy a forrásállományban hány kémiai elem felfedezési adatai
Kémiai elemek felfedezése A kémiai elemek kémiailag tovább már nem bontható, egyszerű anyagok. Jelenleg 118 különböző kémiai elemet ismerünk, közüliik a Földön 94 található meg a természetben, ezeket természetes
RészletesebbenSzámítógépek felépítése
Számítógépek felépítése Emil Vatai 2014-2015 Emil Vatai Számítógépek felépítése 2014-2015 1 / 14 Outline 1 Alap fogalmak Bit, Byte, Word 2 Számítógép részei A processzor részei Processzor architektúrák
RészletesebbenProgramozás alapjai C nyelv 5. gyakorlat. Írjunk ki fordítva! Írjunk ki fordítva! (3)
Programozás alapjai C nyelv 5. gyakorlat Szeberényi Imre BME IIT Programozás alapjai I. (C nyelv, gyakorlat) BME-IIT Sz.I. 2005.10.17. -1- Tömbök Azonos típusú adatok tárolására. Index
RészletesebbenBánsághi Anna anna.bansaghi@mamikon.net
ESEMÉNYVEZÉRELT PROGRAMOZÁS Bánsághi Anna anna.bansaghi@mamikon.net 1. ELŐADÁS - C# ÁTTEKINTÉS - 1 2015 Bánsághi Anna 1 of 84 TEMATIKA I. C# ÁTTEKINTÉS II. WPF III. Modern UI 2015 Bánsághi Anna 2 of 84
RészletesebbenAdatszerkezetek 1. Dr. Iványi Péter
Adatszerkezetek 1. Dr. Iványi Péter 1 Adat Adat minden, amit a számítógépünkben tárolunk és a külvilágból jön Az adatnak két fontos tulajdonsága van: Értéke Típusa 2 Adat típusa Az adatot kódoltan tároljuk
RészletesebbenProgramozási nyelvek Java
statikus programszerkezet Programozási nyelvek Java Kozsik Tamás előadása alapján Készítette: Nagy Krisztián 2. előadás csomag könyvtárak könyvtárak forrásfájlok bájtkódok (.java) (.class) primitív osztály
RészletesebbenProgramozás I. 3. gyakorlat. Szegedi Tudományegyetem Természettudományi és Informatikai Kar
Programozás I. 3. gyakorlat Szegedi Tudományegyetem Természettudományi és Informatikai Kar Antal Gábor 1 Primitív típusok Típus neve Érték Alap érték Foglalt tár Intervallum byte Előjeles egész 0 8 bit
RészletesebbenBánsághi Anna 2014 Bánsághi Anna 1 of 33
IMPERATÍV PROGRAMOZÁS Bánsághi Anna anna.bansaghi@mamikon.net 7. ELŐADÁS - ABSZTRAKT ADATTÍPUS 2014 Bánsághi Anna 1 of 33 TEMATIKA I. ALAPFOGALMAK, TUDOMÁNYTÖRTÉNET II. IMPERATÍV PROGRAMOZÁS Imperatív
RészletesebbenProgramozás alapjai II. (7. ea) C++ Speciális adatszerkezetek. Tömbök. Kiegészítő anyag: speciális adatszerkezetek
Programozás alapjai II. (7. ea) C++ Kiegészítő anyag: speciális adatszerkezetek Szeberényi Imre BME IIT M Ű E G Y E T E M 1 7 8 2 C++ programozási nyelv BME-IIT Sz.I. 2016.04.05. - 1
RészletesebbenSpeciális adatszerkezetek. Programozás alapjai II. (8. ea) C++ Tömbök. Tömbök/2. N dimenziós tömb. Nagyméretű ritka tömbök
Programozás alapjai II. (8. ea) C++ Kiegészítő anyag: speciális adatszerkezetek Szeberényi Imre BME IIT Speciális adatszerkezetek A helyes adatábrázolás választása, a helyes adatszerkezet
RészletesebbenJava II. I A Java programozási nyelv alapelemei
Java2 / 1 Java II. I A Java programozási nyelv alapelemei Miskolci Egyetem Általános Informatikai Tanszék Utolsó módosítás: 2009. 02. 09. Java II.: Alapelemek JAVA2 / 1 A Java formalizmusa A C, illetve
RészletesebbenProgramozás alapjai II. (7. ea) C++
Programozás alapjai II. (7. ea) C++ Kiegészítő anyag: speciális adatszerkezetek Szeberényi Imre BME IIT M Ű E G Y E T E M 1 7 8 2 C++ programozási nyelv BME-IIT Sz.I. 2016.04.05. - 1
RészletesebbenBánsághi Anna anna.bansaghi@mamikon.net
ESEMÉNYVEZÉRELT PROGRAMOZÁS Bánsághi Anna anna.bansaghi@mamikon.net 2. ELŐADÁS - C# ÁTTEKINTÉS - 2 2015 Bánsághi Anna 1 of 64 TEMATIKA I. C# ÁTTEKINTÉS II. WPF III. Modern UI 2015 Bánsághi Anna 2 of 64
Részletesebbenhiányzott szeptemberben vagy A tanuló nem hiányzott szeptemberben szöveget
Hiányzások Ebben a feladatban egy általános iskola 2017 szeptemberi hiányzásai tartalmazó szövegfájlt kell feldolgoznia. Az adatok a szeptember.csv állomány tartalmazza. Az állomány egy sorában egy tanuló
RészletesebbenSzoftvertechnológia alapjai Java előadások
Szoftvertechnológia alapjai Java előadások Förhécz András, doktorandusz e-mail: fandrew@mit.bme.hu tárgy honlap: http://home.mit.bme.hu/~fandrew/szofttech_hu.html A mai előadás tartalma: Miért pont Java?
RészletesebbenOOP #14 (referencia-elv)
OOP #14 (referencia-elv) v1.0 2003.03.19. 21:22:00 Eszterházy Károly Főiskola Információtechnológia tsz. Hernyák Zoltán adj. e-mail: aroan@ektf.hu web: http://aries.ektf.hu/~aroan OOP OOP_14-1 - E jegyzet
RészletesebbenA C programozási nyelv I. Bevezetés
A C programozási nyelv I. Bevezetés Miskolci Egyetem Általános Informatikai Tanszék A C programozási nyelv I. (bevezetés) CBEV1 / 1 A C nyelv története Dennis M. Ritchie AT&T Lab., 1972 rendszerprogramozás,
RészletesebbenA C programozási nyelv I. Bevezetés
A C programozási nyelv I. Bevezetés Miskolci Egyetem Általános Informatikai Tanszék A C programozási nyelv I. (bevezetés) CBEV1 / 1 A C nyelv története Dennis M. Ritchie AT&T Lab., 1972 rendszerprogramozás,
RészletesebbenBME MOGI Gépészeti informatika 1.
BME MOGI Gépészeti informatika 1. 1. feladat Végezze el a következő feladatokat! Olvassa be a nevét és írjon üdvözlő szöveget a képernyőre! Generáljon két 1-100 közötti egész számot, és írassa ki a hányadosukat
RészletesebbenVB C++ C# JScript J# Common Language Specification. ADO.NET and XML. Base Class Library. Common Language Runtime. Operating System
P r o g r a m o z á s i n y e l v e k I I. C # E jegyzet másolata nem használható fel szabadon,az előadás anyagának kivonata. Ezen teljes jegyzetről,vagy annak bármely részéről bármely másolat készítéséhez
RészletesebbenAdatszerkezetek és algoritmusok
2010. január 8. Bevezet El z órák anyagainak áttekintése Ismétlés Adatszerkezetek osztályozása Sor, Verem, Lengyelforma Statikus, tömbös reprezentáció Dinamikus, láncolt reprezentáció Láncolt lista Lassú
RészletesebbenAdatszerkezetek Tömb, sor, verem. Dr. Iványi Péter
Adatszerkezetek Tömb, sor, verem Dr. Iványi Péter 1 Adat Adat minden, amit a számítógépünkben tárolunk és a külvilágból jön Az adatnak két fontos tulajdonsága van: Értéke Típusa 2 Adat típusa Az adatot
RészletesebbenAdatszerkezetek Adatszerkezet fogalma. Az értékhalmaz struktúrája
Adatszerkezetek Összetett adattípus Meghatározói: A felvehető értékek halmaza Az értékhalmaz struktúrája Az ábrázolás módja Műveletei Adatszerkezet fogalma Direkt szorzat Minden eleme a T i halmazokból
RészletesebbenINFORMATIKAI ALAPISMERETEK
Informatikai alapismeretek emelt szint 1021 ÉRETTSÉGI VIZSGA 2011. május 13. INFORMATIKAI ALAPISMERETEK EMELT SZINTŰ ÍRÁSBELI ÉRETTSÉGI VIZSGA JAVÍTÁSI-ÉRTÉKELÉSI ÚTMUTATÓ NEMZETI ERŐFORRÁS MINISZTÉRIUM
RészletesebbenBME MOGI Gépészeti informatika 5.
BME MOGI Gépészeti informatika 5. 1. feladat Készítsen alkalmazást, mely feltölt egy egydimenziós tömböt adott tartományba eső, véletlenszerűen generált egész értékekkel! Határozza meg a legkisebb és a
RészletesebbenAdatbázis rendszerek. dr. Siki Zoltán
Adatbázis rendszerek I. dr. Siki Zoltán Adatbázis fogalma adatok valamely célszerűen rendezett, szisztéma szerinti tárolása Az informatika elterjedése előtt is számos adatbázis létezett pl. Vállalati személyzeti
RészletesebbenDigitális rendszerek. Utasításarchitektúra szintje
Digitális rendszerek Utasításarchitektúra szintje Utasításarchitektúra Jellemzők Mikroarchitektúra és az operációs rendszer közötti réteg Eredetileg ez jelent meg először Sokszor az assembly nyelvvel keverik
RészletesebbenFordított és szkript nyelvek összehasonlító elemzése. Sergyán Szabolcs
Fordított és szkript nyelvek összehasonlító elemzése Sergyán Szabolcs IEEE: The 2016 Top Programming Languages IEEE: The 2016 Top Programming Language (Enterprise) Kutatás-fejlesztésben használt nyelvek
RészletesebbenAdatszerkezetek 1. előadás
Adatszerkezetek 1. előadás Irodalom: Lipschutz: Adatszerkezetek Morvay, Sebők: Számítógépes adatkezelés Cormen, Leiserson, Rives, Stein: Új algoritmusok http://it.inf.unideb.hu/~halasz http://it.inf.unideb.hu/adatszerk
RészletesebbenProgramozás I gyakorlat. 10. Stringek, mutatók
Programozás I gyakorlat 10. Stringek, mutatók Karakter típus A char típusú változókat karakerként is kiírhatjuk: #include char c = 'A'; printf("%c\n", c); c = 80; printf("%c\n", c); printf("%c\n",
RészletesebbenAlgoritmusok és adatszerkezetek gyakorlat 06 Adatszerkezetek
Algoritmusok és adatszerkezetek gyakorlat 06 Adatszerkezetek Tömb Ugyanolyan típusú elemeket tárol A mérete előre definiált kell legyen és nem lehet megváltoztatni futás során Legyen n a tömb mérete. Ekkor:
RészletesebbenBME MOGI Gépészeti informatika 4.
BME MOGI Gépészeti informatika 4. 1. feladat önálló feladatmegoldás Generáljon két 1 és 10 közötti véletlen egész számot, majd kiírja ezekre a számokra a tízes szorzótáblákat! Ha az első generált szám
RészletesebbenAdatszerkezetek 7a. Dr. IványiPéter
Adatszerkezetek 7a. Dr. IványiPéter 1 Fák Fákat akkor használunk, ha az adatok között valamilyen alá- és fölérendeltség van. Pl. könyvtárszerkezet gyökér () Nincsennek hurkok!!! 2 Bináris fák Azokat a
Részletesebben// keressük meg a legnagyobb faktoriális értéket, ami kisebb, // mint százmillió
BME MOGI Gépészeti informatika 3. 1. feladat Végezze el a következő feladatokat! Kérjen be számokat 0 végjelig, és határozza meg az átlagukat! A feladat megoldásához írja meg a következő metódusokat! a.
RészletesebbenInformatika terméktervezőknek
Informatika terméktervezőknek C# alapok Névterület (namespace) using Osztály (class) és Obejtumok Metódus (function, procedure, method) main() static void string[] arg Szintaxis // /* */ \n \t Névadások
RészletesebbenProgramozás alapjai C nyelv 10. gyakorlat. Standard függvények. Union
Programozás alapjai C nyelv 10. gyakorlat Szeberényi Imre BME IIT Programozás alapjai I. (C nyelv, gyakorlat) BME-IIT Sz.I. 2005.11.21. -1- Standard függvények Standard függvények amelyeket
RészletesebbenProgramozás alapjai. 5. előadás
5. előadás Wagner György Általános Informatikai Tanszék Cserélve kiválasztásos rendezés (1) A minimum-maximum keresés elvére épül. Ismétlés: minimum keresés A halmazból egy tetszőleges elemet kinevezünk
RészletesebbenJava bevezet o Kab odi L aszl o Kab odi L aszl o Java bevezet o
Miért Java? széleskörben elterjedt Micro Edition - beágyazott rendszerek, régi telefonok Standard Edition - PC, android ezen alapul Enterprise Edition - vállalati programok, web service-ek multiplatform
RészletesebbenProgramozás BMEKOKAA146. Dr. Bécsi Tamás 2. előadás
Programozás BMEKOKAA146 Dr. Bécsi Tamás 2. előadás Szintaktikai alapok Alapvető típusok, ismétlés C# típus.net típus Méret (byte) Leírás byte System.Byte 1Előjel nélküli 8 bites egész szám (0..255) char
RészletesebbenSzámítástechnika II. BMEKOKAA Előadás. Dr. Bécsi Tamás
Számítástechnika II. BMEKOKAA153 1. Előadás Dr. Bécsi Tamás Bemutatkozás Előadó: Dr. Bécsi Tamás St.106, (1)463-1044, becsi.tamas@mail.bme.hu Közlekedés-, és Járműirányítási Tanszék www.kjit.bme.hu A tantárgyi
RészletesebbenOOP I. Egyszerő algoritmusok és leírásuk. Készítette: Dr. Kotsis Domokos
OOP I. Egyszerő algoritmusok és leírásuk Készítette: Dr. Kotsis Domokos Hallgatói tájékoztató A jelen bemutatóban található adatok, tudnivalók és információk a számonkérendı anyag vázlatát képezik. Ismeretük
RészletesebbenProgramozás alapjai C nyelv 7. gyakorlat. Függvények. Függvények(2)
Programozás alapjai C nyelv 7. gyakorlat Szeberényi Imre BME IIT Programozás alapjai I. (C nyelv, gyakorlat) BME-IIT Sz.I. 2005.11.05. -1- Függvények C program egymás mellé rendelt függvényekből
RészletesebbenOOP #1 (Bevezetés) v1.0 2003.03.07. 18:39:00. Eszterházy Károly Főiskola Információtechnológia tsz. Hernyák Zoltán adj.
OOP #1 (Bevezetés) v1.0 2003.03.07. 18:39:00 Eszterházy Károly Főiskola Információtechnológia tsz. Hernyák Zoltán adj. e-mail: aroan@ektf.hu web: http://aries.ektf.hu/~aroan OOP OOP_01-1 - E jegyzet másolata
RészletesebbenFüggvények. Programozás alapjai C nyelv 7. gyakorlat. LNKO függvény. Függvények(2) LNKO függvény (2) LNKO függvény (3)
Programozás alapjai C nyelv 7. gyakorlat Szeberényi Imre BME IIT Függvények C program egymás mellé rendelt függvényekből áll. A függvény (alprogram) jó absztrakciós eszköz a programok
RészletesebbenGenerikusOsztály<objektumtípus> objektum = new GenerikusOsztály<objektumtípus>();
BME MOGI Gépészeti informatika 17. A C# nyelv generikus típusait a System.Collections.Generics névtérben találhatjuk meg. Ez a névtér számos osztályt és interfészt tartalmaz, amelyek lehetővé teszik előre
RészletesebbenInformációs Technológia
Információs Technológia A C programozási nyelv (Típusok és operátorok) Fodor Attila Pannon Egyetem Műszaki Informatika Kar Villamosmérnöki és Információs Rendszerek Tanszék foa@almos.vein.hu 2010 szeptember
RészletesebbenC programozás. { Márton Gyöngyvér, 2009 } { Sapientia, Erdélyi Magyar Tudományegyetem } http://www.ms.sapientia.ro/~mgyongyi
C programozás Márton Gyöngyvér, 2009 Sapientia, Erdélyi Magyar Tudományegyetem http://www.ms.sapientia.ro/~mgyongyi 1 Könyvészet Kátai Z.: Programozás C nyelven Brian W. Kernighan, D.M. Ritchie: A C programozási
RészletesebbenC#, OOP. Osztályok tervezése C#-ban
C#, OOP Osztályok tervezése C#-ban OOP Létrehozás (creating) Megszüntetés (destroying) Túlterhelés (overlading) Felsorolás típus (enumerated types) 2 Hajó osztály Sailboat class using System; class Sailboat
RészletesebbenSzoftvertervezés és -fejlesztés I.
Szoftvertervezés és -fejlesztés I. Operátorok Vezérlési szerkezetek Gyakorlás 1 Hallgatói Tájékoztató A jelen bemutatóban található adatok, tudnivalók és információk a számonkérendő anyag vázlatát képezik.
RészletesebbenTartalom Keresés és rendezés. Vektoralgoritmusok. 1. fejezet. Keresés adatvektorban. A programozás alapjai I.
Keresés Rendezés Feladat Keresés Rendezés Feladat Tartalom Keresés és rendezés A programozás alapjai I. Hálózati Rendszerek és Szolgáltatások Tanszék Farkas Balázs, Fiala Péter, Vitéz András, Zsóka Zoltán
RészletesebbenProgramozás alapjai. 10. előadás
10. előadás Wagner György Általános Informatikai Tanszék Pointerek, dinamikus memóriakezelés A PC-s Pascal (is) az IBM PC memóriáját 4 fő részre osztja: kódszegmens adatszegmens stackszegmens heap Alapja:
RészletesebbenStack Vezérlés szerkezet Adat 2.
Stack Vezérlés szerkezet Adat 2. Kód visszafejtés. Izsó Tamás 2013. november 14. Izsó Tamás Stack Vezérlés szerkezet Adat 2./ 1 Változó típusú paraméterekátadása 1. #include < s t d i o. h> int64 myfunc
RészletesebbenJárműfedélzeti rendszerek II. 1. előadás Dr. Bécsi Tamás
Járműfedélzeti rendszerek II. 1. előadás Dr. Bécsi Tamás A tárgy órái Előadás hetente (St101) csüt. 8:15 Bécsi Tamás C elmélet Ajánlott irodalom Dennis Ritchie: A C programozási nyelv Gyakorlat hetente
RészletesebbenBevezetés a számítástechnikába
Bevezetés a számítástechnikába Beadandó feladat, kódrendszerek Fodor Attila Pannon Egyetem Műszaki Informatikai Kar Villamosmérnöki és Információs Rendszerek Tanszék foa@almos.vein.hu 2010 október 12.
RészletesebbenKeresés és rendezés. A programozás alapjai I. Hálózati Rendszerek és Szolgáltatások Tanszék Farkas Balázs, Fiala Péter, Vitéz András, Zsóka Zoltán
Keresés Rendezés Feladat Keresés és rendezés A programozás alapjai I. Hálózati Rendszerek és Szolgáltatások Tanszék Farkas Balázs, Fiala Péter, Vitéz András, Zsóka Zoltán 2016. november 7. Farkas B., Fiala
RészletesebbenC# gyorstalpaló. Készítette: Major Péter
C# gyorstalpaló Készítette: Major Péter Adattípusok Logikai változó Egész szám (*: előjel nélküli) Lebegőponto s szám Típus Típusnév másképpen (egyenértékű) Helyigény (bit) Példa bool Boolean 8 (!) true,
RészletesebbenBevezetés, a C++ osztályok. Pere László
Programozás módszertan II. p. Programozás módszertan II. Bevezetés, a C++ osztályok Pere László (pipas@linux.pte.hu) PÉCSI TUDOMÁNYEGYETEM TERMÉSZETTUDOMÁNYI KAR INFORMATIKA ÉS ÁLTALÁNOS TECHNIKA TANSZÉK
RészletesebbenBevezetés a programozásba Előadás: Objektumszintű és osztályszintű elemek, hibakezelés
Bevezetés a programozásba 2 7. Előadás: Objektumszű és osztályszű elemek, hibakezelés ISMÉTLÉS Osztály class Particle { public: Particle( X, X, Y); virtual void mozog( ); ); virtual void rajzol( ) const;
RészletesebbenAdatbázis-kezelő rendszerek. dr. Siki Zoltán
Adatbázis-kezelő rendszerek I. dr. Siki Zoltán Adatbázis fogalma adatok valamely célszerűen rendezett, szisztéma szerinti tárolása Az informatika elterjedése előtt is számos adatbázis létezett pl. Vállalati
RészletesebbenBME MOGI Gépészeti informatika 13.
BME MOGI Gépészeti informatika 13. 1. feladat Készítsen alkalmazást, mely elvégzi a következő feladatokat! a. Állítson elő adott intervallumba eső, adott számú véletlen számot, és írja ki a számokat egy
RészletesebbenMintavételes szabályozás mikrovezérlő segítségével
Automatizálási Tanszék Mintavételes szabályozás mikrovezérlő segítségével Budai Tamás budai.tamas@sze.hu http://maxwell.sze.hu/~budait Tartalom Mikrovezérlőkről röviden Programozási alapismeretek ismétlés
RészletesebbenTorna. A torna.csv UTF-8 kódolású állományban soronként egy versenyző eredményeit tároljuk. Az adatokat pontosvessző választja el egymástól.
Torna A pekingi olimpián tornából hat versenyszámban mérettetik meg magukat a versenyzők. Ennek a versenynek az eredményeit kell feldolgoznia ebben a feladatban. A megoldás során vegye figyelembe a következőket:
RészletesebbenOktatási segédlet 2014
Oktatási segédlet 2014 A kutatás a TÁMOP 4.2.4.A/2-11-1-2012- 0001 azonosító számú Nemzeti Kiválóság Program Hazai hallgatói, illetve kutatói személyi támogatást biztosító rendszer kidolgozása és működtetése
RészletesebbenGenerikus Típusok, Kollekciók
Generikus Típusok, Kollekciók Tóth Zsolt Miskolci Egyetem 2013 Tóth Zsolt (Miskolci Egyetem) Generikus Típusok, Kollekciók 2013 1 / 26 Tartalomjegyzék 1 Enumeráció 2 Generikus Típusok 3 Kollekciók System.Collections
RészletesebbenProgramozás alapjai. (GKxB_INTM023) Dr. Hatwágner F. Miklós szeptember 27. Széchenyi István Egyetem, Gy r
Programozás alapjai (GKxB_INTM023) Széchenyi István Egyetem, Gy r 2018. szeptember 27. Háromszög szerkeszthet ségének ellen rzése ANSI C (C89) megvalósítás #i n c l u d e i n t main ( v
RészletesebbenFunkcionális és logikai programozás. { Márton Gyöngyvér, 2012} { Sapientia, Erdélyi Magyar Tudományegyetem }
Funkcionális és logikai programozás { Márton Gyöngyvér, 2012} { Sapientia, Erdélyi Magyar Tudományegyetem } http://www.ms.sapientia.ro/~mgyongyi ` 1 Jelenlét: Követelmények, osztályozás Az első 4 előadáson
RészletesebbenProgramozás alapjai C nyelv 4. gyakorlat. Mit tudunk már? Feltételes operátor (?:) Típus fogalma char, int, float, double
Programozás alapjai C nyelv 4. gyakorlat Szeberényi Imre BME IIT Programozás alapjai I. (C nyelv, gyakorlat) BME-IIT Sz.I. 2005.10.10.. -1- Mit tudunk már? Típus fogalma char, int, float,
RészletesebbenAlkalmazott modul: Programozás 4. előadás. Procedurális programozás: iteratív és rekurzív alprogramok. Alprogramok. Alprogramok.
Eötvös Loránd Tudományegyetem Informatikai Kar Alkalmazott modul: Programozás 4. előadás Procedurális programozás: iteratív és rekurzív alprogramok Giachetta Roberto groberto@inf.elte.hu http://people.inf.elte.hu/groberto
RészletesebbenSzámítástechnika I. BMEKOKAA152 BMEKOKAA119 Infokommunikáció I. BMEKOKAA606. Dr. Bécsi Tamás 2. előadás
Számítástechnika I. BMEKOKAA152 BMEKOKAA119 Infokommunikáció I. BMEKOKAA606 Dr. Bécsi Tamás 2. előadás Console I/O bővebben Lásd mintaprogram 2015.09.21. Számítástechnika I. 2. Előadás 2 Számábrázolásról
Részletesebbentalálhatók. A memória-szervezési modell mondja meg azt, hogy miként
Memória címzési módok Egy program futása során (legyen szó a program vezérléséről vagy adatkezelésről) a program utasításai illetve egy utasítás argumentumai a memóriában találhatók. A memória-szervezési
Részletesebben10. gyakorlat Tömb, mint függvény argumentum
10. gyakorlat Tömb, mint függvény argumentum 1. feladat: A 6. gyakorlat 1. feladatát oldja meg a strukturált programtervezési alapelv betartásával, azaz minden végrehajtandó funkciót külön függvényben
RészletesebbenC# osztályok. Krizsán Zoltán
C# osztályok Krizsán Zoltán Fogalma Önálló hatáskőrrel rendelkező, absztrakt adattípus, amely több, különböző elemet tartalmazhat. Minden esetben a heap-en jön létre! A programozó hozza létre, de a GC
RészletesebbenProgramozás. (GKxB_INTM021) Dr. Hatwágner F. Miklós április 4. Széchenyi István Egyetem, Gy r
Programozás (GKxB_INTM021) Széchenyi István Egyetem, Gy r 2018. április 4. Számok rendezése Feladat: Fejlesszük tovább úgy a buborék rendez algoritmust bemutató példát, hogy a felhasználó adhassa meg a
RészletesebbenMutatók és címek (ism.) Programozás alapjai C nyelv 8. gyakorlat. Indirekció (ism) Néhány dolog érthetőbb (ism.) Változók a memóriában
Programozás alapjai C nyelv 8. gyakorlat Szeberényi mre BME T Programozás alapjai. (C nyelv, gyakorlat) BME-T Sz.. 2005.11.07. -1- Mutatók és címek (ism.) Minden változó és függvény
RészletesebbenProgramozás 6. Dr. Iványi Péter
Programozás 6. Dr. Iványi Péter 1 Előfeldolgozás része Makrók A forrás kódban elvégzi a helyettesítéseket a fordító Csak egyszer végez helyettesítést Nem olyan makrók, mint a LISP vagy Scheme esetén Csak
Részletesebben11. gyakorlat Sturktúrák használata. 1. Definiáljon dátum típust. Olvasson be két dátumot, és határozza meg melyik a régebbi.
11. gyakorlat Sturktúrák használata I. Új típus új műveletekkel 1. Definiáljon dátum típust. Olvasson be két dátumot, és határozza meg melyik a régebbi. typedef struct datum { int ev; int ho; int nap;
RészletesebbenAdattípusok, vezérlési szerkezetek. Informatika Szabó Adrienn szeptember 14.
Informatika 1 2011 Második előadás, vezérlési szerkezetek Szabó Adrienn 2011. szeptember 14. Tartalom Algoritmusok, vezérlési szerkezetek If - else: elágazás While ciklus For ciklus Egyszerű típusok Összetett
RészletesebbenBME MOGI Gépészeti informatika 8.
BME MOGI Gépészeti informatika 8. 1. feladat Készítse beosztottak és vezetők munkahelyi adatait kezelő alkalmazást! A feladat megoldásához hozza létre a következő osztályokat! Beosztott osztály: adatmező
Részletesebben