Week5_Practicum

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// Opdracht 5.1 prototypes
void opdracht5_1();
int count(int n, int* a, int len);
// Opdracht 5.2 prototypes
void opdracht5_2();
char* herhaal(char* s,int n);

// Opdracht 5.3 prototypes
typedef struct node {
    int data;
    struct node * nextNode;
}NODE, *NODEPtr;

NODEPtr  tailNode;// = {1, NULL};
NODEPtr  headNode;// = {2, &tailNode};

void opdracht5_3();
void addFirst(int data);
void addLast(int data);
void deleteItem(int data);
void initBaseNodes();
NODEPtr lookUpByValue(int data, NODEPtr node, int limit);
NODEPtr lookUpByPointer(NODEPtr node, NODEPtr listStart, int limit);
NODEPtr getPreviousNode(NODEPtr node, NODEPtr listStart, int limit);
// Opdracht 5.4 prototypes
void opdracht5_4();
void insert(int data, NODEPtr node);
void initNodes();
int isSorted();

NODEPtr  sortedTailNode;
NODEPtr  sortedHeadNode;

// Opdracht 5.5 prototypes
struct listNode {
int data;
struct listNode* next;
};
typedef struct listNode ListNode;

struct queue {
ListNode* head;
ListNode* tail;
};
typedef struct queue Queue;

void opdracht5_5();
Queue* newQueue();
void freeQueue(Queue* q);
void enqueue(Queue* q, int data);
int dequeue(Queue* q);
void show(Queue* q);
int main()
{
    printf("!...Starting Application...!\n");
    printf("node pointer size: %d, \n", sizeof(NODEPtr));
    printf("node size: %d, \n", sizeof(NODE));
    printf("\n___Opdracht 5_1___\n");
    opdracht5_1();
    printf("\n___Opdracht 5_2___\n");
    opdracht5_2();
    printf("\n___Opdracht 5_3___\n");
    opdracht5_3();
    printf("\n___Opdracht 5_4___\n");
    opdracht5_4();
    printf("\n___Opdracht 5_5___\n");
    opdracht5_5();
    printf("!...Ending Application...!\n");
    while(1);
    return 0;
}
void opdracht5_1()  {
    int a[] = {5, 4, 5, 3, 1, 2, 5, 5};
    int len = sizeof(a)/sizeof(a[0]);
    int i = count(5,a,len);
    printf("value is %d\n", i);
}
int count(int n, int* a, int len)   {

    int temp = 0;
    if(len > 1)
        temp = count(n, (a+1), len-1);
    if(*a == n)
        temp++;
    return temp;
}
void opdracht5_2()  {
    char* resultaatHerhaal = herhaal("sad", 2);
    printf("opdracht5_2 = %s\n", resultaatHerhaal);
}
char* herhaal(char* s,int n)   {
    char* temp = s;
    if(n > 1)   {
        char *prevStep = herhaal(s, n - 1);
        temp = malloc(strlen(s)+strlen(prevStep)+1);
        temp[0] = '\0';
        strcat(temp,prevStep);
        strcat(temp,s);
    }
    return temp;
}
void garbageTest()  {
    int* test = malloc(1000000);
    free(test);
}
void opdracht5_3()          {
    initBaseNodes();
    //printf("Cur value is = %d\n", headNode->nextNode->data);

    addFirst(5);
    addFirst(4);
    addLast(6);
    addLast(9);

    int a = headNode->nextNode->nextNode->nextNode->data;
    int b = headNode->nextNode->nextNode->nextNode->data;
    NODEPtr temp = lookUpByValue(2, headNode, 5);
    garbageTest();
    //printf("wimbple\n");
    //printf("floopy\n");
    deleteItem(4);
    deleteItem(9);
    deleteItem(5);
    deleteItem(6);
    addFirst(5);
    printf("value of node %d\n", tailNode->nextNode->data);
    printf("Howmany elements? %d\n", tailNode->data);

}
NODEPtr lookUpByValue(int data, NODEPtr node, int limit)  {
    NODEPtr returnNode = NULL;
    if(node->data == data && limit > 0)
        return node;
    else
        returnNode = lookUpByValue(data, node->nextNode, (limit - 1));
    return returnNode;
}
NODEPtr lookUpByPointer(NODEPtr node, NODEPtr listStart, int limit)   {
    NODEPtr curNode = NULL;
    if(limit > 0)   {
        if(node == listStart)
            return node;
        else
            curNode = lookUpByPointer(node, listStart->nextNode, limit - 1);
    }
    return curNode;
}
NODEPtr getPreviousNode(NODEPtr node, NODEPtr listStart, int limit) {
    NODEPtr curNode = NULL;
    if(limit > 0)   {
        printf("got here...\n");
        if(node == listStart->nextNode) {
            printf("got here too...\n");
            return listStart;
        }
        else
            curNode = getPreviousNode(node, listStart->nextNode, limit - 1);
    }
    printf("value here is %d \n", curNode->data);
    return curNode;
}
void initBaseNodes()    {
    tailNode = malloc(sizeof(NODE));
    tailNode->data = 0;
    tailNode->nextNode = NULL;
    headNode = malloc(sizeof(NODE));
    headNode->data = 2;
    headNode->nextNode = tailNode;
    //tailNode = (NODEPtr){0, NULL     };
    //headNode = (NODEPtr){2, tailNode };
}
void addFirst(int data)     {
    NODEPtr next = malloc(sizeof(NODE));
    next->data = data;
    next->nextNode = headNode->nextNode;
    headNode->nextNode = next;
    if(tailNode->nextNode == NULL)
        tailNode->nextNode = next;
    tailNode->data++;
}
void addLast(int data)      {
    NODEPtr lastElement = malloc(sizeof(NODE));
    lastElement->data = data;
    tailNode->nextNode->nextNode = lastElement;
    tailNode->nextNode = lastElement;
    lastElement->nextNode = tailNode;
    tailNode->data++;
}
void deleteItem(int data)   {
    NODEPtr nodeForRemoval = lookUpByValue(data, headNode, 10);
    NODEPtr temp2 = lookUpByPointer(nodeForRemoval, headNode, 10);

    NODEPtr temp3 = getPreviousNode(nodeForRemoval, headNode, 10);
    printf("\n____ %d %d ____\n", temp2->data, temp3->nextNode->data);
    temp3->nextNode = nodeForRemoval->nextNode;
    if(nodeForRemoval == tailNode->nextNode)
        tailNode->nextNode = temp3;
    free(nodeForRemoval);
    tailNode->data--;
    if(tailNode->data == 0)
        tailNode->nextNode = NULL;
}
void opdracht5_4()      {
    initNodes();
    insert(12, sortedHeadNode);
    //insert(5, sortedHeadNode);
    //insert(19, sortedHeadNode);
    //insert(14, sortedHeadNode);
    //insert(24, sortedHeadNode);
    printf("node on this spot is %d \n", sortedHeadNode->nextNode->nextNode->data);
    printf("Is the list sorted? 1 is yes, 0 is no. Answer is: %d", isSorted(sortedHeadNode->data, sortedHeadNode));
}
void insert(int data, NODEPtr node)   {
    NODEPtr sortedNewNode = malloc(sizeof(NODE));
    sortedNewNode->data = data;
    if(node->nextNode->data >= data)
        insert(data, node->nextNode);
    else    {
        sortedNewNode->nextNode = node->nextNode;
        node->nextNode = sortedNewNode;
    }
}
void initNodes()        {
    sortedTailNode = malloc(sizeof(NODE));
    sortedTailNode->data = 0;
    sortedTailNode->nextNode = NULL;
    sortedHeadNode = malloc(sizeof(NODE));
    sortedHeadNode->data = 0xFFFF;
    sortedHeadNode->nextNode = sortedTailNode;
}
int isSorted(int curValue, NODEPtr node)          {
    char returnIfError = 1;
    if(node->nextNode != NULL && node->data < node->nextNode->data)
        return 0;
    if(node->nextNode != NULL) {
        returnIfError = isSorted(node->data,  node->nextNode);
    }
    else
        return 1;
}
void opdracht5_5()  {
    Queue* q = newQueue();
    enqueue(q, 5);
    enqueue(q, 12);
    printf("value here is %d\n", q->head->next->data);
    freeQueue(q);
    enqueue(q, 5);
    enqueue(q, 8);
    dequeue(q);
    dequeue(q);
    enqueue(q, 5);
    enqueue(q, 10);
    printf("added element is %d and %d\n", q->head->data, q->tail->data);
    show(q);
}
Queue* newQueue()   {
    Queue* queueCreator = malloc(sizeof(Queue));
    queueCreator->tail = malloc(sizeof(ListNode));
    queueCreator->tail = -1;
    queueCreator->tail = NULL;

    queueCreator->head = malloc(sizeof(ListNode));
    queueCreator->head->data = -1;
    queueCreator->head = NULL;

    return queueCreator;
}
void freeQueue(Queue* q)    {
    ListNode* cNode = q->head;
    while(cNode != NULL && cNode != NULL)    {
        ListNode* tempSwap = cNode->next;
        if(cNode != q->head && cNode != q->tail)
            free(cNode);
        cNode = tempSwap;
    }
    q->head->data = -1;
    q->head = NULL;
    q->tail->data = -1;
    q->tail = NULL;
}
void enqueue(Queue* q, int data)    {
    ListNode* newQueueMember = (ListNode*)malloc(sizeof(ListNode));
    if(q->head == NULL)
        q->head = newQueueMember;

    newQueueMember->data = data;
    newQueueMember->next = NULL;
    if(q->tail == NULL)
        q->tail = newQueueMember;

    q->tail->next = newQueueMember;
    q->tail = newQueueMember;
    q->tail->next = NULL;
}
int dequeue(Queue* q)   {
    ListNode* newQueueMember = q->head;
    if(q->head->next == NULL)
        freeQueue(q);
    else    {
        q->head = q->head->next;
        free(newQueueMember);
    }
    return 1;
}
void show(Queue* q)     {
    ListNode* cNode = q->head;
    while(cNode != NULL)    {
        printf("node data \t%d\n", cNode->data);
        cNode = cNode->next;
    }

}