153 lines
6.1 KiB
Plaintext
153 lines
6.1 KiB
Plaintext
{
|
|
int myArray[] = {34, 23, 78, 41, 7, 87, 52, 36, 29, 42};
|
|
//
|
|
void selectoinSort(int a[], const int &n){
|
|
int i = 0;
|
|
while(i < n){
|
|
int min = i;
|
|
int j = i + 1;
|
|
while(j < n){
|
|
if(a[j] < a[min]){
|
|
min = j;
|
|
}
|
|
j = j + 1;
|
|
}
|
|
if(min != i){
|
|
swap(a[i], a[min])
|
|
}
|
|
i = i + 1;
|
|
}
|
|
}
|
|
//
|
|
selectionSort(myArray, 10);
|
|
}
|
|
| ID | PTR | INDEX | VALUE |
|
|
:------:-------:---------:-----------:
|
|
| x | seq | 0 |
|
|
// array
|
|
| 1 | int | 0 | 34 |
|
|
...
|
|
| 1 | int | 9 | 42 |
|
|
|
|
class fun{
|
|
WORD* argv[];
|
|
};
|
|
|
|
// | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
|
|
// 1
|
|
// A
|
|
// |
|
|
//reserverd bit
|
|
//
|
|
// | typename | var-0 | var-1 | var-2 |
|
|
// byte-0 addr-1 addr-2 addr-3
|
|
Atom:
|
|
+-----atom-----+
|
|
| +--------+ |
|
|
| | sor id | |
|
|
| +--------+ |
|
|
+--------------+
|
|
>nem tudunk csak atomra ugrani
|
|
>az atomok eddig instrukció fajtától függően határoztuk meg, viszont kreatívabban is lehetne
|
|
|
|
### Original ###
|
|
Folyamatábra_elem : "Folyamatábra elem"; atom név
|
|
AD_ID : "AlgoDetail ID"; atom id ^ ^ ^ \_ elsődleges kulcs
|
|
Ssz : "?!"; sor id . . . . . . . . . /
|
|
V : "Változó"; cím
|
|
V_ndx : "Változó iNDeX"; cím offset // >>>NOTE1
|
|
VM : "Változó Művelet"
|
|
func : "FUNCió"; függvény hívás // >>>NOTE3
|
|
J id : "Jump ID"; ugrás célpont; egy atom id
|
|
// azt hiszem nyújt egy fajta biztonságot
|
|
( \
|
|
V1 : "Változó 1" \
|
|
V_ndx : "Változó iNDeX"; inkonzisztens módon nincs megszámozva /* >>>NOTE1 */\
|
|
C1 : "Constant 1" \
|
|
) \
|
|
AM : "Alg Művelet" } >>>NOTE2
|
|
( /
|
|
V2 /
|
|
V_ndx /
|
|
C2 /
|
|
) /
|
|
VB1 \
|
|
CB1 \
|
|
F1 \
|
|
VJ1 \
|
|
CJ1 \
|
|
LM : "?! Művelet" } >>>NOTE2
|
|
VB2 /
|
|
CB2 /
|
|
F2 /
|
|
VJ2 /
|
|
CJ2 /
|
|
|
|
NOTE:
|
|
>hunglish
|
|
>1*: a változónév alapból magasszintű absztraktció; csak az olvashatóság/parsibleness kedvéért van értelme külön kezelni
|
|
>3*: teljesen redundáns az ugrás mező miatt, hacsak nem a paramétereket is belekódoljuk.
|
|
ebben az esetben kell egy módszer amivel egy kifejezésben utalhatunk egy tömb N. elemére ami inkonzistens
|
|
a [Név] [Index] oszlop felépítéssel
|
|
>2*: ismétéls; a 2 igazán indokolatlan szám; logikusan vagy 1 feltételt mentek és tovább kezelem,
|
|
vagy végtelelen feltételt határozhatok meg egy sorban; az előbbi a logikus
|
|
az oszlop számok homogenitása miatt
|
|
|
|
30 oszlop
|
|
legalább 10 redundáns
|
|
|
|
### Revoked ###
|
|
enum JMP {
|
|
no,
|
|
always,
|
|
wt, //when true
|
|
wf //when false
|
|
}
|
|
(IN) (OUT)
|
|
| LN | JMP | DEST | ASSIGNEMT | OPR1 | OPERATOR | OPR2 | COMMENT |
|
|
1 0 i = 0 0 0
|
|
2 3 return 0 i < &argv[2]
|
|
3 0 min = i 0 0
|
|
4 0 j = i + 1
|
|
5 3 9 0 j < n
|
|
6 3 8 0 a[j] < a[min]
|
|
7 0 min = j 0 0
|
|
8 0 j += 1 0 0
|
|
9 2 13 0 min = i
|
|
10 0 call[0] = &a[i] 0 0
|
|
11 0 call[1] = &a[min] 0 0
|
|
12 1 &swap 0 call 0 0
|
|
13 0 i += 1
|
|
14 1 return 0 0 0 0
|
|
|
|
9 oszlop
|
|
0 redundancia
|
|
|
|
|
|
(IN) (OUT)
|
|
| Address | PK2 | JMP | DEST | ASSIGNEMT | OPR1 | OPERATOR | OPR2 | COMMENT |
|
|
1 1 0 i = 0 0 0
|
|
2 1 3 return 0 i < &argv[2]
|
|
3 1 0 min = i 0 0
|
|
3 2 0 j = i + 1
|
|
4 1 3 9 0 j < n
|
|
5 1 3 8 0 a[j] < a[min]
|
|
6 1 0 min = j 0 0
|
|
6 2 0 j += 1 0 0
|
|
7 1 2 13 0 min = i
|
|
8 1 0 call[0] = &a[i] 0 0
|
|
8 2 0 call[1] = &a[min] 0 0
|
|
8 3 1 &swap 0 call 0 0
|
|
9 1 0 i += 1
|
|
10 1 1 return 0 0 0 0
|
|
|
|
10 oszlop
|
|
az atom fogalma megmaradt -> mivel JT-ben nincs ilyen mekötés ezért értelmetlen megtartani
|
|
|
|
// can oracle/mysql fork?
|
|
// is varchar allocated inline?
|
|
|
|
since JT is ordered insertion is a nightmare
|
|
|
|
the deletion problem is actually self evident. an elems life time is as long as we have any data on it.
|