Zde můžete vidět rozdíly mezi vybranou verzí a aktuální verzí dané stránky.
Obě strany předchozí revizePředchozí verze | |||
pitel:ial:ial_du1 [09. 10. 2013, 08.09:30] – file pitel | pitel:ial:ial_du1 [30. 12. 2022, 13.43:01] (aktuální) – upraveno mimo DokuWiki 127.0.0.1 | ||
---|---|---|---|
Řádek 1: | Řádek 1: | ||
+ | ====== 1. domácí úloha ====== | ||
+ | [[wp> | ||
+ | <file c c201.c> | ||
+ | void InitList (tList *L) { | ||
+ | L -> act = NULL; //prazdny aktualni | ||
+ | L -> frst = NULL; //prazdny konec | ||
+ | } | ||
+ | |||
+ | void DisposeList (tList *L) { | ||
+ | while (L -> frst != NULL) { //dokud nezrusim vsechny prvky | ||
+ | tElemPtr x = L -> frst; //nastav docasny ukazatel na prvni prvek | ||
+ | L -> frst = L -> frst -> ptr; //nastav prvni prvek na druhy prvek | ||
+ | free(x); //zrus docasny ukazatel (byvaly prvni prvek) | ||
+ | } | ||
+ | L -> act = NULL; | ||
+ | } | ||
+ | |||
+ | void InsertFirst (tList *L, int val) { | ||
+ | tElemPtr prvek; //novy prvek | ||
+ | if ((prvek = malloc(sizeof(struct tElem))) == NULL ) { //jeho alokace | ||
+ | Error(); //a osetreni chyby | ||
+ | return; | ||
+ | } | ||
+ | prvek -> data = val; //nastaveni hodnoty noveho prvku | ||
+ | prvek -> ptr = L -> frst; //novy prvni prvek musi ukazovat na ten stary | ||
+ | L -> frst = prvek; //a novy prvni je skutecne prvni | ||
+ | } | ||
+ | |||
+ | void First (tList *L) { | ||
+ | L -> act = L -> frst; //aktualni ukazuje na prvni | ||
+ | } | ||
+ | |||
+ | void CopyFirst (tList *L, int *val) { | ||
+ | if (L -> frst == NULL) { //kdyz je prazdny | ||
+ | Error(); //vyvola chybu | ||
+ | return; | ||
+ | } | ||
+ | *val = L -> frst -> data; //precte a vrati hodnotu | ||
+ | } | ||
+ | |||
+ | void DeleteFirst (tList *L) { | ||
+ | if (L -> frst == NULL) { //kdyz je prazdny | ||
+ | return; //nic nedelej | ||
+ | } | ||
+ | if (L -> act == L -> frst) { //kdyz je prvni aktivni | ||
+ | L -> act = NULL; //deaktivuj ho | ||
+ | } | ||
+ | tElemPtr x = L -> frst; //zalozni ukazatlen na prvni | ||
+ | L -> frst = L -> frst -> ptr; //prvni bude ted druhy | ||
+ | free(x); //zrus stary prvni | ||
+ | } | ||
+ | |||
+ | void PostDelete (tList *L) { | ||
+ | if (L -> act == NULL || L -> act -> ptr == NULL) { //neni aktivni nebo je posledni prvek | ||
+ | return; //nic nedelej | ||
+ | } | ||
+ | tElemPtr x = L -> act -> ptr; //docasny ukazatel na nasledujici prvek | ||
+ | L -> act -> ptr = L -> act -> ptr -> ptr; //ukazatel na nasledujici musi ukazovat na ten jeste dalsi nasledujici | ||
+ | free(x); //zrusit stary nasledujici | ||
+ | } | ||
+ | |||
+ | void PostInsert (tList *L, int val) { | ||
+ | if (L -> act == NULL) { //neni aktivni | ||
+ | return; //nedlej nic | ||
+ | } | ||
+ | tElemPtr prvek; //novy prvek | ||
+ | if ((prvek = malloc(sizeof(struct tElem))) == NULL ) { //zkusime naalokovat | ||
+ | Error(); //nebo skoncime | ||
+ | return; | ||
+ | } | ||
+ | prvek -> data = val; //naplnime hodnotu | ||
+ | prvek -> ptr = L -> act -> ptr; //ukazeme na nasledujici prvek | ||
+ | L -> act -> ptr = prvek; //a novy nasledujici bude nas novy prvek | ||
+ | } | ||
+ | |||
+ | void Copy (tList *L, int *val) { | ||
+ | if (L -> act == NULL) { //kdyz neni nic aktivni | ||
+ | Error(); //zarveme | ||
+ | return; //a skoncime | ||
+ | } | ||
+ | *val = L -> act -> data; //precteme aktivni data | ||
+ | } | ||
+ | |||
+ | void Actualize (tList *L, int val) { | ||
+ | if (L -> act == NULL) { //kdyz neni aktivni | ||
+ | return; //konec | ||
+ | } | ||
+ | L -> act -> data = val; //zapise nova data do aktivniho prvku | ||
+ | } | ||
+ | |||
+ | void Succ (tList *L) { | ||
+ | if (L -> act == NULL) { //nic neni aktivni | ||
+ | return; //konec | ||
+ | } | ||
+ | L -> act = L -> act -> ptr; //presuneme aktivitu na nasledujici | ||
+ | } | ||
+ | |||
+ | int Active (tList *L) { | ||
+ | /* | ||
+ | if (L -> act == NULL) { | ||
+ | return 0; | ||
+ | } else { | ||
+ | return 1; | ||
+ | } | ||
+ | */ | ||
+ | return L -> act != NULL; | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | <file c c203.c> | ||
+ | void queueInit ( tQueue* q ) { | ||
+ | if (q == NULL) { //kdyz nic | ||
+ | queueError(QERR_INIT); | ||
+ | } else { | ||
+ | for (unsigned int i = 0; i < QUEUE_SIZE; i++) { // | ||
+ | q -> arr[i] = '?'; | ||
+ | } | ||
+ | q -> f_index = 0; // | ||
+ | q -> b_index = 0; | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int nextIndex ( int index ) { | ||
+ | return (index + 1) % QUEUE_SIZE; | ||
+ | } | ||
+ | |||
+ | int queueEmpty ( const tQueue* q ) { | ||
+ | return q -> f_index == q -> b_index; | ||
+ | } | ||
+ | |||
+ | int queueFull ( const tQueue* q ) { | ||
+ | return q-> | ||
+ | } | ||
+ | |||
+ | char queueFront ( const tQueue* q ) { | ||
+ | if (queueEmpty(q) != 0) { // kdyz prazdna | ||
+ | queueError(QERR_FRONT); | ||
+ | return -1; //zkoncit | ||
+ | } else { | ||
+ | return q -> arr[q -> f_index]; //vratit znak na prvnim miste | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void queueRemove ( tQueue* q ) { | ||
+ | if (queueEmpty(q) != 0) { //kdyz prazdna | ||
+ | queueError(QERR_REMOVE); | ||
+ | } else { | ||
+ | q -> f_index = nextIndex(q -> f_index); //bude prvni nasledujici znak (protoci frontu) | ||
+ | } | ||
+ | } | ||
+ | |||
+ | char queueGet ( tQueue* q ) { | ||
+ | if (queueEmpty(q) != 0) { //kdyz prazdna | ||
+ | queueError(QERR_GET); | ||
+ | return -1; //umri | ||
+ | } else { | ||
+ | char x = queueFront(q); | ||
+ | queueRemove(q); | ||
+ | return x; //vrat byvaly porvni znak | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void queueUp ( tQueue* q, char c ) { | ||
+ | if (queueFull(q) != 0) { //kdyz prazdna | ||
+ | queueError(QERR_UP); | ||
+ | } else { | ||
+ | q -> arr[q -> b_index] = c; //nacpi na prazdne misto znak | ||
+ | q -> b_index = nextIndex(q -> b_index); //posun na dalsi prazdne misto | ||
+ | } | ||
+ | } | ||
+ | </ | ||
+ | |||
+ | <file c c206.c> | ||
+ | void DLInitList (tDLList *L) { | ||
+ | L -> Act = NULL; //prazdny aktualni | ||
+ | L -> First = NULL; //prazdny prvni | ||
+ | L -> Last = NULL; //prazdny posledni | ||
+ | } | ||
+ | |||
+ | void DLDisposeList (tDLList *L) { | ||
+ | while (L -> First != NULL) { //dokud nezrusim vsechny prvky | ||
+ | tDLElemPtr x = L -> First; //nastav docasny ukazatel na prvni prvek | ||
+ | L -> First = L -> First -> rptr; //nastav prvni prvek na druhy prvek | ||
+ | free(x); //zrus docasny ukazatel (byvaly prvni prvek) | ||
+ | } | ||
+ | L -> Act = NULL; //vymaz zbytky | ||
+ | L -> Last = NULL; | ||
+ | } | ||
+ | |||
+ | void DLInsertFirst (tDLList *L, int val) { | ||
+ | tDLElemPtr prvek; //novy prvek | ||
+ | if ((prvek = malloc(sizeof(struct tDLElem))) == NULL) { //jeho alokace | ||
+ | DLError(); | ||
+ | return; | ||
+ | } | ||
+ | prvek -> data = val; //nastaveni hodnoty noveho prvku | ||
+ | prvek -> rptr = L -> First; //novy prvni prvek musi ukazovat na ten stary | ||
+ | prvek -> lptr = NULL; //prvek je prvni, takze zarucime ze vlevo nic neni | ||
+ | if (L -> First != NULL) { | ||
+ | L -> First -> lptr = prvek; //kdyz novy prvek neni do prazdneho seznamu, bude stary prvni prvek ukazovat na aktualni | ||
+ | } else { | ||
+ | L -> Last = prvek; //vklafani do rpazdneho seznamu | ||
+ | } | ||
+ | L -> First = prvek; //a novy prvni je skutecne prvni | ||
+ | } | ||
+ | |||
+ | void DLInsertLast(tDLList *L, int val) { | ||
+ | tDLElemPtr prvek; //novy prvek | ||
+ | if ((prvek = malloc(sizeof(struct tDLElem))) == NULL) { //jeho alokace | ||
+ | DLError(); | ||
+ | return; | ||
+ | } | ||
+ | prvek -> data = val; //nastaveni hodnoty noveho prvku | ||
+ | prvek -> lptr = L -> Last; //novy posledni prvek musi ukazovat na ten stary | ||
+ | prvek -> rptr = NULL; //prvek je posledni, takze zarucime ze vpravo nic neni | ||
+ | if (L -> Last != NULL) { | ||
+ | L -> Last -> rptr = prvek; //neprazdny seznam | ||
+ | } else { | ||
+ | L -> First = prvek; //prazdny seznam | ||
+ | } | ||
+ | L -> Last = prvek; //a novy prvni je skutecne posledni | ||
+ | |||
+ | } | ||
+ | |||
+ | void DLFirst (tDLList *L) { | ||
+ | L -> Act = L -> First; //aktalni je prvni | ||
+ | } | ||
+ | |||
+ | void DLLast (tDLList *L) { | ||
+ | L -> Act = L -> Last; //aktualni je posledni | ||
+ | } | ||
+ | |||
+ | int DLCopyFirst (tDLList *L) { | ||
+ | if (L -> Last == NULL && L -> First == NULL) { //kdyz je prazdny | ||
+ | DLError(); | ||
+ | return -1; | ||
+ | } | ||
+ | return L -> First -> data; //precte a vrati prvni hodnotu | ||
+ | } | ||
+ | |||
+ | int DLCopyLast (tDLList *L) { | ||
+ | if (L -> Last == NULL && L -> First == NULL) { //kdyz je prazdny | ||
+ | DLError(); | ||
+ | return -1; | ||
+ | } | ||
+ | return L -> Last -> data; //precte a vrati posledni hodnotu | ||
+ | } | ||
+ | |||
+ | void DLDeleteFirst (tDLList *L) { | ||
+ | if (L -> Last == NULL && L -> First == NULL) { //kdyz je seznam prazdny | ||
+ | return; | ||
+ | } | ||
+ | if (L -> First != NULL) { | ||
+ | tDLElemPtr x = L -> First; //docasny prvek | ||
+ | if (L -> Act == L -> First) { //kdyz je prvni aktivni | ||
+ | L -> Act = NULL; //deaktivuj ho | ||
+ | } | ||
+ | if (L -> First == L -> Last) { //pokud je mazany posledni | ||
+ | L -> First = NULL; //vynuluj | ||
+ | L -> Last = NULL; | ||
+ | } else { //jinak | ||
+ | L -> First = L -> First -> rptr; //dalsi prvni | ||
+ | L -> First -> lptr = NULL; //vlevo nic | ||
+ | } | ||
+ | free(x); //uvolni | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void DLDeleteLast (tDLList *L) { | ||
+ | if (L -> Last == NULL && L -> First == NULL) { | ||
+ | return; //kdyz je seznam prazdny, nedelej nic | ||
+ | } | ||
+ | tDLElemPtr x; | ||
+ | if (L -> Last != NULL) { | ||
+ | x = L -> Last; | ||
+ | if (L -> Act == L -> Last) { //kdyz je prvni aktivni | ||
+ | L -> Act = NULL; //deaktivuj ho | ||
+ | } | ||
+ | if (L -> First == L -> Last) { //kdyz je seznam skoro prazdny | ||
+ | L -> First = NULL; //vynuluj | ||
+ | L -> Last = NULL; | ||
+ | } else { | ||
+ | L -> Last = L -> Last -> lptr; //posledni bude predposledni | ||
+ | L -> Last -> rptr = NULL; //vpravo nic | ||
+ | } | ||
+ | free(x); //uvolni | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void DLPostDelete (tDLList *L) { | ||
+ | if (L -> Act != NULL && L -> Act -> rptr != NULL) { //kdyz je seznam aktivni a je co mazat (aktivni neni posledni) | ||
+ | tDLElemPtr x = L -> Act -> rptr; //zalohuj mazany | ||
+ | L -> Act -> rptr = x -> rptr; //posun ukazatel | ||
+ | if (x == L -> Last) { | ||
+ | L -> Last = L -> Act; //kdyz je mazany posledni, bude posledni i aktualni | ||
+ | } else { | ||
+ | x -> rptr -> lptr = L -> Act; //kdyz ne, cerna magie | ||
+ | } | ||
+ | free(x); //uvolni | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void DLPreDelete (tDLList *L) { | ||
+ | if (L -> Act != NULL && L -> Act -> lptr != NULL) { //kdyz je seznam aktivni a je co mazat (aktivni neni prvni) | ||
+ | tDLElemPtr x = L -> Act -> lptr; //zalohuj mazany | ||
+ | L -> Act -> lptr = x -> lptr; //posun ukazatel | ||
+ | if (x == L -> First) { | ||
+ | L -> First = L -> Act; //kdyz je mazany prvni, bude prvni aktualni | ||
+ | } else { | ||
+ | x -> lptr -> rptr = L -> Act; //kdyz ne, cerna magie | ||
+ | } | ||
+ | free(x); //uvolni | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void DLPostInsert (tDLList *L, int val) { | ||
+ | if (L -> Act != NULL) { // kdyz je seznam aktivni | ||
+ | tDLElemPtr x; //novy prvek | ||
+ | if ((x = malloc(sizeof(struct tDLElem))) == NULL) { //jeho alokace | ||
+ | DLError(); | ||
+ | return; | ||
+ | } | ||
+ | x -> data = val; //napln data | ||
+ | x -> rptr = L -> Act -> rptr; | ||
+ | x -> lptr = L -> Act; | ||
+ | L -> Act -> rptr = x; | ||
+ | if (L -> Act == L -> Last) { | ||
+ | L -> Last = x; // kdyz je aktivni posledni, bude posledni novy | ||
+ | } else { | ||
+ | x -> rptr -> lptr = x; //jinak cerna magie | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | void DLPreInsert (tDLList *L, int val) { | ||
+ | if (L -> Act != NULL) { //kdyz je seznam aktivni | ||
+ | tDLElemPtr x; //novy prvek | ||
+ | if ((x = malloc(sizeof(struct tDLElem))) == NULL) { //jeho alokace | ||
+ | DLError(); | ||
+ | return; | ||
+ | } | ||
+ | x -> data = val; //napln data | ||
+ | x -> lptr = L -> Act -> lptr; | ||
+ | x -> rptr = L -> Act; | ||
+ | L -> Act -> lptr = x; | ||
+ | if (L -> Act == L -> First) { | ||
+ | L -> First = x; //kdyz je aktivni prvni, bude prvni novy | ||
+ | } else { | ||
+ | x -> lptr -> rptr = x; //jinak cerna magie | ||
+ | } | ||
+ | } | ||
+ | } | ||
+ | |||
+ | int DLCopy (tDLList *L) { | ||
+ | if (L -> Act == NULL) { //kdyz neni nic aktivni | ||
+ | DLError(); | ||
+ | return -1; //a skoncime | ||
+ | } | ||
+ | return L -> Act -> data; //precteme aktivni data | ||
+ | } | ||
+ | |||
+ | void DLActualize (tDLList *L, int val) { | ||
+ | if (L -> Act == NULL) { //nic neni aktivni | ||
+ | return; //konec | ||
+ | } | ||
+ | L -> Act -> data = val; //presuneme aktivitu na nasledujici | ||
+ | } | ||
+ | |||
+ | void DLSucc (tDLList *L) { | ||
+ | if (L -> Act == NULL) { //nic neni aktivni | ||
+ | return; //konec | ||
+ | } | ||
+ | L -> Act = L -> Act -> rptr; //presuneme aktivitu na nasledujici | ||
+ | } | ||
+ | |||
+ | void DLPred (tDLList *L) { | ||
+ | if (L -> Act == NULL) { //nic neni aktivni | ||
+ | return; //konec | ||
+ | } | ||
+ | L -> Act = L -> Act -> lptr; //presuneme aktivitu na predchozi | ||
+ | } | ||
+ | |||
+ | int DLActive (tDLList *L) { | ||
+ | return L -> Act != NULL; | ||
+ | } | ||
+ | </ |