easy as 123

[lil jurk]

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct Bacterie {
    char nume[30];
    int grad;
};

struct ListNode {
    struct Bacterie bacterie;
    struct ListNode * next;
};
 
struct LinkedList {
    struct ListNode * firstNode;
    unsigned size;
};

struct LinkedList * createLinkedList() {
    struct LinkedList * list = (struct LinkedList *) malloc(sizeof(struct LinkedList));
    list->firstNode == NULL;
    list->size = 0;
    return list;
}

unsigned linkedListSize(struct LinkedList * list) {
    return list->size;
}

struct ListNode *createNode(struct Bacterie bacterie) {
    struct ListNode * node = (struct ListNode *) malloc(sizeof(struct ListNode));
        node->bacterie = bacterie;
        node->next = NULL;
        return node;
}    

void linkedListInsert(struct LinkedList *list, struct Bacterie bacterie) {
    struct ListNode *tmpNode = createNode(bacterie);
    if (list->size == 0) {
        list->firstNode = tmpNode;
        list->size = 1;
        return;
    }
    if (tmpNode->bacterie.grad > list->firstNode->bacterie.grad) {
    	tmpNode->next = list->firstNode;
    	list->firstNode = tmpNode;
    	list->size++;
    	return;
	}   
    struct ListNode *tmpNode1 = list->firstNode;
    while (tmpNode1->next != NULL && tmpNode1->next->bacterie.grad >= tmpNode->bacterie.grad) {
    	tmpNode1 = tmpNode1->next;
    }
    if (tmpNode1->next == NULL) {
    	tmpNode1->next = tmpNode;
    	list->size++;
    	return;
    }
    tmpNode->next = tmpNode1->next;
    tmpNode1->next = tmpNode;
    list->size++;
}

char linkedListContains(struct LinkedList *list, struct Bacterie bacterie) {
	struct ListNode *tmpNode = list->firstNode;
	while (tmpNode != NULL) {
		if (strcmp(tmpNode->bacterie.nume, bacterie.nume) == 0) {
			return 1;
		}
		tmpNode = tmpNode->next;
	}
		return 0;
}
	    	   
void printList(struct LinkedList *list) {
	int i;
	struct ListNode *tmpNode = list->firstNode;
	for (i = 0; i < list->size; i++) {
		printf("%s", tmpNode->bacterie.nume);
		tmpNode = tmpNode->next;
	}  
}

void printFirst(struct LinkedList *list) {
	printf("%s\n", list->firstNode->bacterie.nume);
}
  
struct Bacterie readfromKeyboard() {
    struct Bacterie bacterie;
    printf("[Nume]:");
    fgets(bacterie.nume, 30, stdin);
    if (bacterie.nume[0] == '-') {
        return bacterie;
    }
    printf("[Grad de risc]:");
    scanf("%d", &bacterie.grad);
    getchar();
    return bacterie;
}

int main() {
	struct Bacterie bacterie[100];
	struct LinkedList *listaBacterii = createLinkedList();
	int i = 1;
	printf("[Bacteria 1]\n");
	bacterie[i] = readfromKeyboard();
	while (bacterie[i].nume[0] != '-') {
		if (linkedListContains(listaBacterii, bacterie[i]) == 0) {
			linkedListInsert(listaBacterii, bacterie[i]);
			i++;
		}
			printf("[Bacteria %d]\n", i);		
			bacterie[i] = readfromKeyboard();
	}
	printList(listaBacterii);
	printFirst(listaBacterii);
	return 0;
}
	
		
		
......................


#include <stdio.h>
#include <stdlib.h>
#include <string.h>


struct Elev {
    char nume[30];
    char prenume[30];
    char cnp[14];
    unsigned media;
};

int compare(char *cnp1, char *cnp2) {
    return strcmp(cnp1, cnp2);
}

struct Pair {
    char * key;
    struct Elev elev;
};
 
struct TreeNode {
    struct TreeNode * parent;
    struct TreeNode * left;
    struct TreeNode * right;
    struct Pair pair;
};
 
struct TreeMap {
    struct TreeNode * root;
    unsigned size;
};

struct TreeMap * createTreeMap() {
    struct TreeMap *map = (struct TreeMap *) calloc(1, sizeof(struct TreeMap));
    return map;
}

unsigned treeMapSize(struct TreeMap * map) {
    return map->size;
}

char treeMapIsEmpty(struct TreeMap * map) {
    if (map->size == 0) {
        return 1;
    }
    return 0;
}

void treeMapPut(struct TreeMap * map, char * key, struct Elev elev) {
    if (map->size == 0) {
        struct TreeNode * newNode = (struct TreeNode *) malloc(sizeof(struct TreeNode));
        newNode->pair.key = key;
        newNode->pair.elev = elev;
        newNode->parent = newNode->left = newNode->right = NULL;
        map->root = newNode;
        map->size = 1;
        return;
    }
    struct TreeNode *tmpNode = map->root;
    while (1) {
    if (compare(tmpNode->pair.key, key) == 0) {
        tmpNode->pair.key = key;
        tmpNode->pair.elev = elev;
        return;
    }
    if (compare(tmpNode->pair.key, key) > 0 && tmpNode->left != NULL) {
        tmpNode = tmpNode->left;
    }
    if (compare(tmpNode->pair.key, key) > 0 && tmpNode->left == NULL) {
        struct TreeNode * newNode = (struct TreeNode *) malloc(sizeof(struct TreeNode));
        newNode->pair.key = key;
        newNode->pair.elev = elev;
        newNode->parent = newNode->left = newNode->right = NULL;
        newNode->parent = tmpNode;
        tmpNode->left = newNode;
        map->size++;
        return;
    }
    if (compare(tmpNode->pair.key, key) < 0 && tmpNode->right != NULL) {
        tmpNode = tmpNode->right;
    }
    if (compare(tmpNode->pair.key, key) < 0 && tmpNode->right == NULL) {
        struct TreeNode * newNode = (struct TreeNode *) malloc(sizeof(struct TreeNode));
        newNode->pair.key = key;
        newNode->pair.elev = elev;
        newNode->parent = newNode->left = newNode->right = NULL;
        newNode->parent = tmpNode;
        tmpNode->right = newNode;
        map->size++;
        return;
    }
    }
}

void printNode(struct TreeNode *node) {
    if (node == NULL) return;
    printNode(node->left);
    printf("%s", node->pair.elev.cnp);
    printNode(node->right);
}


void treePrint(struct TreeMap *map) {
    printNode(map->root);
}

void treeMapModify(struct TreeMap * map, char * key) {
    struct TreeNode *tmpNode = map->root;
    while (tmpNode != NULL) {
        if (compare(tmpNode->pair.key, key) == 0) {
            tmpNode->pair.elev.media = 0;
            return;
        }
        if (compare(tmpNode->pair.key, key) > 0) {
            tmpNode = tmpNode->left;
        }
        if (compare(tmpNode->pair.key, key) < 0) {
            tmpNode = tmpNode->right;
        }
    }
}

void printMap(struct TreeMap *map, char * key) {
    struct TreeNode *tmpNode = map->root;
    while (tmpNode != NULL) {
        if (compare(tmpNode->pair.key, key) == 0) {
            printf("[%s][%s] - RESPINS\n", tmpNode->pair.elev.nume, tmpNode->pair.elev.prenume);
            return;
        }
        if (compare(tmpNode->pair.key, key) > 0) {
            tmpNode = tmpNode->left;
        }
        if (compare(tmpNode->pair.key, key) < 0) {
            tmpNode = tmpNode->right;
        }
    }
}       

struct Elev readFromKeyboard() {
    struct Elev elev;
    printf("nume:");
    scanf("%s", elev.nume);
    printf("prenume:");
    scanf("%s", elev.prenume);
    printf("cnp:");
    scanf("%s", elev.cnp);
    printf("media:");
    scanf("%d", &elev.media);
    return elev;
}

int main() {
    struct Elev elev[100];
    struct TreeMap *map = createTreeMap();
    int i = 0;
    while(1) {
        elev[i] = readFromKeyboard();
        if (elev[i].media < 0 || elev[i].media > 10) {
            break;
        }
        treeMapPut(map,elev[i].cnp, elev[i]);
        i++;
    }
    treePrint(map);
    char cnp1[14], cnp2[14], cnp3[14];
        printf("primul cnp");
        scanf("%s", cnp1);
        treeMapModify(map, cnp1);
        printf("al doilea cnp");
        scanf("%s", cnp2);
        treeMapModify(map, cnp2);
        printf("al treilea cnp");
        scanf("%s", cnp3);
        treeMapModify(map, cnp3);
        printMap(map, cnp1);
        printMap(map, cnp2);
        printMap(map, cnp3);
        return 0;
}

[SamuelAdams]

I don't see a question.