Eduardo Nava / Mbed 2 deprecated MazeRunner_Fall2017

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   4DGL-uLCD-SE mbed wave_player

Fork of MazeRunner_Fall2017-shell by Eduardo Nava

doublely_linked_list.cpp

Committer:
navaem
Date:
2017-12-29
Revision:
1:2c6ae0fe9a2a
Parent:
0:cf4396614a79

File content as of revision 1:2c6ae0fe9a2a:

#include <stdlib.h>
#include <stdio.h>
#include "doublely_linked_list.h"

DLinkedList* create_dlinkedlist(void) {
    DLinkedList* newList = (DLinkedList*)malloc(sizeof(DLinkedList));
    newList->head = NULL;
    newList->tail = NULL;
    newList->current = NULL;
    newList->size = 0;
    return newList;
}

//i made
LLNode* create_llnode(void* data) {

    LLNode* newNode = (LLNode*)malloc(sizeof(LLNode));
    newNode->previous = NULL;
    newNode->next = NULL;
    newNode->data = data;
    return newNode;
}


void insertHead(DLinkedList* dLinkedList, void* data){
  LLNode* newNode = create_llnode(data);
  if(dLinkedList->head == NULL){
    dLinkedList->size++;
    dLinkedList->head = newNode;
    dLinkedList->tail = newNode;
  }else{
    dLinkedList->size++;
    newNode->next = dLinkedList->head;
    (dLinkedList->head)->previous = newNode;
    dLinkedList->head = newNode;
  }

}

//i made
void insertTail(DLinkedList* dLinkedList, void* data){

  LLNode* newNode = create_llnode(data);
  if(dLinkedList->head == NULL){
    dLinkedList->size++;
    dLinkedList->head = newNode;
    dLinkedList->tail = newNode;
  }else {
    dLinkedList->size++;
    newNode->previous = dLinkedList->tail;
    (dLinkedList->tail)->next = newNode;
    dLinkedList->tail = newNode;
  } 
}

//i made
int insertAfter(DLinkedList* dLinkedList, void* newData){

    if(dLinkedList->current==NULL){
        return 0;
    }else if(dLinkedList->current==dLinkedList->tail){
        insertTail(dLinkedList, newData);
        return 1;
    }
    else{
        LLNode* newNode = create_llnode(newData);
        LLNode* nextNode = (dLinkedList->current)->next;
        nextNode->previous = newNode;
        (dLinkedList->current)->next = newNode;
        newNode->previous = dLinkedList->current;
        newNode->next = nextNode;
        dLinkedList->size++;
        return 1;
    }
}

//i made
int insertBefore(DLinkedList* dLinkedList, void* newData){

    if (dLinkedList->current == NULL)
        return 0;
    else if(dLinkedList->current==dLinkedList->head){
        insertHead(dLinkedList,newData);
        return 1;
    }
    else {
        LLNode* newNode = create_llnode(newData);
        LLNode* prevNode = (dLinkedList->current)->previous;
        prevNode->next = newNode;
        (dLinkedList->current)->previous = newNode;
        newNode->previous = prevNode;
        newNode->next = dLinkedList->current;
        dLinkedList->size++;
        return 1;
    }
}

//i made
void* deleteBackward(DLinkedList* dLinkedList){
    LLNode* currNode = dLinkedList->current;
    if (currNode == NULL)
        return NULL;
    else if (getSize(dLinkedList)==1){
        dLinkedList->current = NULL;
        dLinkedList->head = NULL;
        dLinkedList->tail = NULL;
        free(currNode->data);
        free(currNode);
        dLinkedList->size--;
        return NULL;
    } else if(currNode == dLinkedList->head){
        dLinkedList->head = currNode->next;
        dLinkedList->current = NULL;
        (dLinkedList->head)->previous = NULL;
        free(currNode->data);
        free(currNode);
        dLinkedList->size--;
        return NULL;
    } else if(currNode == dLinkedList->tail){
        dLinkedList->tail = currNode->previous;
        (dLinkedList->tail)->next = NULL;
        dLinkedList->current = dLinkedList->tail;
        free(currNode->data);
        free(currNode);
        dLinkedList->size--;
        return getCurrent(dLinkedList);
    } else {
        (currNode->previous)->next = currNode->next;
        dLinkedList->current = currNode->previous;
        (currNode->next)->previous = dLinkedList->current;
        free(currNode->data);
        free(currNode);
        dLinkedList->size--;
        return getCurrent(dLinkedList);
    }
}


//i made
void* deleteForward(DLinkedList* dLinkedList)
{
    LLNode* currNode = dLinkedList->current;
    if (currNode == NULL)
        return NULL;
    else if (getSize(dLinkedList)==1){
        dLinkedList->current = NULL;
        dLinkedList->head = NULL;
        dLinkedList->tail = NULL;
        free(currNode->data);
        free(currNode);
        dLinkedList->size--;
        return NULL;
    } else if(currNode == dLinkedList->head){
        dLinkedList->head = currNode->next;
        dLinkedList->current = currNode->next;
        (dLinkedList->head)->previous = NULL;
        free(currNode->data);
        free(currNode);
        dLinkedList->size--;
        return getCurrent(dLinkedList);
    } else if(currNode == dLinkedList->tail){
        dLinkedList->tail = currNode->previous;
        (dLinkedList->tail)->next = NULL;
        dLinkedList->current = NULL;
        free(currNode->data);
        free(currNode);
        dLinkedList->size--;
        return NULL;
    } else {
        (currNode->next)->previous = currNode->previous;
        dLinkedList->current = currNode->next;
        (currNode->previous)->next = dLinkedList->current;
        free(currNode->data);
        free(currNode);
        dLinkedList->size--;
        return getCurrent(dLinkedList);
    }
}

//i made
void* removeBackward(DLinkedList* dLinkedList){
    LLNode* currNode = dLinkedList->current;
    if (currNode == NULL)
        return NULL;
    else if (getSize(dLinkedList)==1){
        void* ldata = currNode->data;
        dLinkedList->current = NULL;
        dLinkedList->tail = NULL;
        dLinkedList->head = NULL;
        dLinkedList->size--;
        free(currNode);
        return ldata;
    }else if (dLinkedList->current == dLinkedList->head){
        void* ldata = currNode->data;
        dLinkedList->head = currNode->next;
        (dLinkedList->head)->previous = NULL;
        dLinkedList->current = NULL;
        dLinkedList->size--;
        free(currNode);
        return ldata;
    }else if (dLinkedList->current == dLinkedList->tail){
        void* ldata = currNode->data;
        dLinkedList->current = currNode->previous;
        dLinkedList->tail = currNode->previous;
        (dLinkedList->tail)->next = NULL;
        dLinkedList->size--;
        free(currNode);
        return ldata;
    }else {
        void* ldata = currNode->data;
        dLinkedList->current = currNode->previous;
        (dLinkedList->current)->next = currNode->next;
        (currNode->next)->previous = dLinkedList->current;
        dLinkedList->size--;
        free(currNode);
        return ldata;
    }

}

//i made
void* removeForward(DLinkedList* dLinkedList)
{
    LLNode* currNode = dLinkedList->current;
    if (currNode == NULL)
        return NULL;
    else if (getSize(dLinkedList)==1){
        void* ldata = currNode->data;
        dLinkedList->current = NULL;
        dLinkedList->tail = NULL;
        dLinkedList->head = NULL;
        dLinkedList->size--;
        free(currNode);
        return ldata;
    }else if (dLinkedList->current == dLinkedList->head){
        void* ldata = currNode->data;
        dLinkedList->head = currNode->next;
        (dLinkedList->head)->previous = NULL;
        dLinkedList->current = currNode->next;
        dLinkedList->size--;
        free(currNode);
        return ldata;
    }else if (dLinkedList->current == dLinkedList->tail){
        void* ldata = currNode->data;
        dLinkedList->current = NULL;
        dLinkedList->tail = currNode->previous;
        (dLinkedList->tail)->next = NULL;
        free(currNode);
        dLinkedList->size--;
        return ldata;
    }else {
        void* ldata = currNode->data;
        dLinkedList->current = currNode->next;
        (dLinkedList->current)->previous = currNode->previous;
        (currNode->previous)->next = dLinkedList->current;
        free(currNode);
        dLinkedList->size--;
        return ldata;
    }

}


void destroyList(DLinkedList* dLinkedList){
  if(dLinkedList->head != NULL){
    getHead(dLinkedList);
    while(deleteForward(dLinkedList)){};
  }
  free(dLinkedList);
}

//i made
void* getHead(DLinkedList* dLinkedList){

    LLNode* head = dLinkedList->head;
    if (head == NULL)
        return NULL;
    else {
        dLinkedList->current = dLinkedList->head;
        return head->data;
    }
}


//i made
void* getTail(DLinkedList* dLinkedList){

    LLNode* tail = dLinkedList->tail;
    if (tail == NULL)
        return NULL;
    else {
        dLinkedList->current = dLinkedList->tail;
        return tail->data;
    }
}


//i made
void* getCurrent(DLinkedList* dLinkedList){

    LLNode* currNode = dLinkedList->current;
    if (currNode==NULL)
        return NULL;
    else
        return currNode->data;
}


//i made
void* getNext(DLinkedList* dLinkedList){

    LLNode* currNode = dLinkedList->current;
    if (currNode == NULL)
        return NULL;
    else if (currNode->next == NULL) {
        dLinkedList->current = NULL;
        return NULL;
    }else{
        dLinkedList->current = currNode->next;
        return (currNode->next)->data;
    }   
}


//i made
void* getPrevious(DLinkedList* dLinkedList){

    LLNode* currNode = dLinkedList->current;
    if (currNode == NULL)
        return NULL;
    else if (currNode->previous == NULL) {
        dLinkedList->current = NULL;
        return NULL;
    }else{
        dLinkedList->current = currNode->previous;
        return (currNode->previous)->data;
    }
}

//i made
int getSize(DLinkedList* dLinkedList){

    return dLinkedList->size;
}