1. domácí úloha

Linked list

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;
}

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
	}
}

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;
}