P2 Source

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

priorityqueue_t* pqueue_create(void) {
    priorityqueue_t *tmp = malloc(sizeof(priorityqueue_t));  //Speicher für Queue reservieren
    if(tmp == NULL) {
        printf("Kein Speicher für Queue verfügbar\n");
        return NULL;
    }
    else { //   0-te Position wird erstellt und Queue
        tmp -> size = 0;
        tmp -> head = NULL;
        return tmp;
    }
}

void pqueue_insert(priorityqueue_t *pq, char *value, float p) {

    if(pq == NULL) {                //Abfrage ob Queue vorhanden
        printf("Warteschlange ist nicht vorhanden\n");
        return;
    }

    //Neues Element
    pquentry_t *newElement = malloc(sizeof(pquentry_t)); //speicherplatz reservieren
    if(newElement == NULL) {
        printf("Kein Speicher verfügbar für Element\n");
        return;
    }

    newElement -> p = p; // Element kriegt p als Priorität

    int counter = 0;    //Werkzeug um Länge zu ermitteln etc.
    for(int x = 0; value[x] != '\0'; x++) { //laenge ermitteln und  in counter einfügen
        counter++;
    }

    newElement -> value = malloc((counter + 1)*sizeof(char)); //Speicher für Wert des neuen Elements
    if(newElement -> value == NULL) {           //Überprüfung des Werts
        printf(" Element kann folgenden Wert nicht erhalten  \n");
        return;    }


    for(int x = 0; x < counter + 1; x++) {   //Value kriegt einen String
        newElement -> value[x] = value[x];
    }

    //Einfügen in die Liste
    if(pq -> size == 0) {         //Überprüfung ob nur ein Element in der Liste
        pq -> head = newElement;
        pq -> size++;
        newElement -> next = NULL;
    }
    else {
        newElement -> next = NULL;
        pq -> size++;

        pquentry_t *temp = pq -> head; //tempörärer Zeiger der durchgeht um richtig einzusotiren

        //Element einsortieren
        if(newElement -> p < temp -> p) {
            newElement -> next = temp;
            pq -> head = newElement;
            return;
        }

        while(temp->next) {
            if(newElement -> p <= temp -> next -> p) {
                newElement -> next = temp -> next;
                temp -> next = newElement;
                return;
            }
            else {
                temp = temp-> next;
            }
        }
        temp->next = newElement;
    }
}

char* pqueue_extractMinimum(priorityqueue_t *pq) {
    //Liste ist schon sortiert also einfach erstes Element rausnehmen
    char* minimum = pq -> head -> value;
    pquentry_t *tmp = pq -> head;
    pq -> head = tmp -> next;

    free(tmp->value);
    free(tmp);
    pq -> size--;
    //printf("Minimum: %s\n", minimum);
    return minimum;
}

void pqueue_decreaseKey(priorityqueue_t *pq, char *value, float p) {
    if(pq == NULL || pq -> size == 0) { //Liste Leer
        return;
    }
    else if (pq -> size == 1) { //Bei einem Element muss die Reihenfolge nicht geändert werden
        pq -> head -> p = p;
        return;
    }
    else { //Element entfernen und mit neuer Priorität an die richtige Stelle einfügen
        pqueue_remove(pq, value);
        pqueue_insert(pq, value, p);
        return;
    }
}

void pqueue_remove(priorityqueue_t *pq, char *value) {
    if(pq == NULL || pq -> size == 0) {     //kicken der geringsten prioritat
        printf("Shishabar wird renoviert\n");
        return;
    }

    pquentry_t *curr = pq -> head; //neues temp

    //Wenn erstes Element gelöscht wird, dann anderer Löschvorgang
    if(strcmp(value, curr -> value) == 0) {
        //strcmp(value, curr -> value) == 0
        pq -> head = curr -> next;
        free(curr);
        pq -> size--;
        return;
    }

    //Alle anderen Elemente
    for(int x = 0; x < ((pq -> size)-1); x++) {
        if(strcmp(value, curr -> next -> value) == 0) {
            pquentry_t *tmp = curr -> next;
            curr -> next = curr -> next -> next;
            free(tmp->value);
            free(tmp);
            pq -> size--;
            return;
        }
        curr -> next = curr -> next -> next;
    }
}

void pqueue_destroy(priorityqueue_t *pq) {
    if(pq == NULL) {
        return;
    }
    else if(pq -> size == 0) {      //wenn warteschlange vorhanden wo 0 eintrag oder keine warteschlange nichts ansonnst loschen mit temporare zeiger
        free(pq);
        return;
    }
    else {
        pquentry_t *tmp = pq -> head;
        while(pq -> size != 0) {
            pq->head = pq->head->next;
            free(tmp);
            pq -> size--;
            tmp = pq->head;
        }
        free(pq);
        return;
    }
}

void pqueue_print(priorityqueue_t *pq) {
    pquentry_t *tmp = pq -> head;
    printf("\n");
    printf("--Anfang der Liste--\n");
    for(int x = 0; x < pq -> size; x++) {
        printf("Anzahl %d: Priorität: %f Value: %12s|\n", x, tmp -> p, tmp -> value);      //gibt ganze elemente der warteschlange aus und beinnt von anfang
        tmp = tmp -> next;
    }
    printf("--Ende der Liste--\n");
}