Kalábovi

Kalábovic wikina

Uživatelské nástroje

Nástroje pro tento web

Historie:
pitel:ial:ial_du1

Rozdíly

Zde můžete vidět rozdíly mezi vybranou verzí a aktuální verzí dané stránky.

Odkaz na výstup diff

Obě strany předchozí revizePředchozí verze
pitel:ial:ial_du1 [09. 10. 2013, 08.09:30] – file pitelpitel: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>Linked_list|Linked list]]
  
 +<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>
 +
 +<file c c203.c>
 +void queueInit ( tQueue* q ) {
 + if (q == NULL) { //kdyz nic
 + queueError(QERR_INIT); //tak zarvat
 + } else {
 + for (unsigned int i = 0; i < QUEUE_SIZE; i++) { //vyprazdneni
 + q -> arr[i] = '?';
 + }
 + q -> f_index = 0; //vynulovani indexu
 + 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->f_index == nextIndex(q->b_index);
 +}
 +
 +char queueFront ( const tQueue* q ) {
 + if (queueEmpty(q) != 0) { // kdyz prazdna
 + queueError(QERR_FRONT); //zarvat
 + 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); //zarvat
 + } 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); //zarvi
 + return -1; //umri
 + } else {
 + char x = queueFront(q); //uloz prvni znak
 + queueRemove(q); //odstrank prvni znak
 + return x; //vrat byvaly porvni znak
 + }
 +}
 +
 +void queueUp ( tQueue* q, char c ) {
 + if (queueFull(q) != 0) { //kdyz prazdna
 + queueError(QERR_UP); //zarvi
 + } 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>
 +
 +<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(); //a osetreni chyby
 + 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(); //a osetreni chyby
 + 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(); //vyvola chybu
 + 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(); //vyvola chybu
 + 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(); //a osetreni chyby
 + 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(); //a osetreni chyby
 + 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(); //zarveme
 + 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;
 +}
 +</file>
/var/www/wiki/data/attic/pitel/ial/ial_du1.1381306170.txt.bz2 · Poslední úprava: 30. 12. 2022, 13.43:01 (upraveno mimo DokuWiki)

Nástroje pro stránku

Kromě míst, kde je explicitně uvedeno jinak, je obsah této wiki licencován pod následující licencí: CC Attribution-Share Alike 4.0 International
CC Attribution-Share Alike 4.0 International Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki