doublyLinkedList.h File Reference

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

Include dependency graph for doublyLinkedList.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	_Node_
struct	_List_

Typedefs
typedef struct _Node_	Node
typedef struct _List_	List

Functions
Node *	createNode (void)
	Allocates memory for a new node and initalizes it.
bool	freeNode (Node *node)
	Frees the memory of a node.
List *	createList (void)
	Allocates memory for a new list and initalizes it.
bool	freeList (List *list)
	Frees the memory of a list and all nodes in it.
Node *	appendNodeToEndOfList (List *list, Node *node, bool check_for_existing_node)
	Append a node to the end of a list.
List *	appendListToEndOfList (List *list, List *list_to_append)
bool	removeNodeFromList (List *list, Node *node)
	Removes a node from the list.
Node *	removeNodeWithValue (List *list, int data)
	Remove a node from a list with a specific value of playing_card_.
Node *	remove_first (List *list)
	Remove first node in list.
bool	checkElementInList (Node *current_node, Node *node_to_check)
	Checks if the adress of a node is already in a list (rekursive)
void	printList (List *list)
	Print the whole List without trailing .

Typedef Documentation

List

typedef struct _List_ List

Definition at line 11 of file doublyLinkedList.h.

Node

typedef struct _Node_ Node

Definition at line 10 of file doublyLinkedList.h.

Function Documentation

appendListToEndOfList()

List * appendListToEndOfList	(	List *	list,
		List *	list_to_append )

Definition at line 139 of file doublyLinkedList.c.

{
  if (list->size_ == 0)
  {
    list->first_ = list_to_append->first_;
    list->last_ = list_to_append->last_;
    list->size_ = list_to_append->size_;
  }
  else
  {
    list->last_->next_ = list_to_append->first_;     // Set next from last element in list to the new node
    list_to_append->first_->previous_ = list->last_;
    list->last_ = list_to_append->last_;
    list->size_ = list->size_ + list_to_append->size_;
  }
  list_to_append->first_ = NULL;
  list_to_append->last_ = NULL;
  list_to_append->size_ = 0;
  return list;
}

References _List_::first_, _List_::last_, _Node_::next_, _Node_::previous_, and _List_::size_.

appendNodeToEndOfList()

Node * appendNodeToEndOfList	(	List *	list,
		Node *	node,
		bool	check_for_existing_node )

Append a node to the end of a list.

Parameters

list	Address of the list to append to
node	Address of the node
check_for_existing_node	true: same node can only be saved once | false: the same node can be saved multiple times

Returns

Returns the address of the appendend node

Definition at line 115 of file doublyLinkedList.c.

{
  // Element is already in the list
  if ((check_for_existing_node ? checkElementInList(list->first_, node) : false))
  {
    return node;
  }
 
  if (list->size_ == 0)
  {
    list->first_ = node;
    list->last_ = node;
    list->size_++;
  }
  else
  {
    list->last_->next_ = node;     // Set next from last element in list to the new node
    node->previous_ = list->last_; // Set pointer to now second last element
    list->last_ = node;
    list->size_++;
  }
  return node;
}

References checkElementInList(), _List_::first_, _List_::last_, _Node_::next_, _Node_::previous_, and _List_::size_.

Referenced by FunctionCall().

Here is the call graph for this function:

Here is the caller graph for this function:

checkElementInList()

bool checkElementInList	(	Node *	current_node,
		Node *	node_to_check )

Checks if the adress of a node is already in a list (rekursive)

Parameters

current_node	Address of the node to begin the check
node_to_check	The address of the node to check

Returns

Returns true if the element is already in the list.

Definition at line 89 of file doublyLinkedList.c.

{
  // Check if list is empty
  if (current_node == NULL)
  {
    return false;
  }
  // Check if the current node is the same as the one to check
  if (current_node == node_to_check)
  {
    return true;
  }
  // Else go recursive into the function with the next element in the list
  else
  {
    return checkElementInList(current_node->next_, node_to_check);
  }
  return false;
}

References checkElementInList(), and _Node_::next_.

Referenced by appendNodeToEndOfList(), and checkElementInList().

Here is the call graph for this function:

Here is the caller graph for this function:

createList()

List * createList

(

void

)

Allocates memory for a new list and initalizes it.

Returns

Returns address of the created list

Definition at line 38 of file doublyLinkedList.c.

{
  List *list = (List *)malloc(sizeof(List));
  if (list == NULL)
  {
    return NULL;
  }
 
  list->size_ = 0;
  list->first_ = NULL;
  list->last_ = NULL;
 
  return list;
}

References _List_::first_, _List_::last_, and _List_::size_.

Referenced by FunctionCall().

Here is the caller graph for this function:

createNode()

Node * createNode

(

void

)

Allocates memory for a new node and initalizes it.

Returns

Returns address of the created node

Definition at line 6 of file doublyLinkedList.c.

{
  Node *node = (Node *)malloc(sizeof(Node));
  if (node == NULL)
  {
    return NULL;
  }
 
  // Initialize node
  node->next_ = NULL;
  node->previous_ = NULL;
  node->data_ = 0;
 
  return node;
}

References _Node_::data_, _Node_::next_, and _Node_::previous_.

Referenced by FunctionCall().

Here is the caller graph for this function:

freeList()

bool freeList

(

List *

list

)

Frees the memory of a list and all nodes in it.

Parameters

list	Address to a List struct

Returns

true if the list and all nodes has been freed / false if list was NULL

Definition at line 56 of file doublyLinkedList.c.

{
  if (list == NULL)
  {
    return false;
  }
 
  int list_size = list->size_;
  if (list_size > 0)
  {
    Node *current_node;
    for (int i = 0; i < list_size; i++)
    {
      current_node = list->last_;
      if (!removeNodeFromList(list, current_node))
      {
        return false;
      }
      if (!freeNode(current_node))
      {
        return false;
      }
    }
  }
 
  free(list);
  return true;
}

References freeNode(), _List_::last_, removeNodeFromList(), and _List_::size_.

Referenced by FunctionCall().

Here is the call graph for this function:

Here is the caller graph for this function:

freeNode()

bool freeNode

(

Node *

node

)

Frees the memory of a node.

Parameters

node	Address to a Node struct

Returns

true if the node has been freed / false if node was NULL

Definition at line 25 of file doublyLinkedList.c.

{
  if (node == NULL)
  {
    return false;
  }
 
  free(node);
  return true;
}

Referenced by freeList().

Here is the caller graph for this function:

printList()

void printList

(

List *

list

)

Print the whole List without trailing
.

Parameters

list	List to be printed

Definition at line 271 of file doublyLinkedList.c.

{
  Node *current_node = list->first_;
  int count = 0;
  while (current_node != NULL)
  {
    // Example print if data is an integer
    printf("List element %d, value: %d\n", count, current_node->data_);
    current_node = current_node->next_;
    count ++;
  }
}

References _Node_::data_, _List_::first_, and _Node_::next_.

Referenced by FunctionCall().

Here is the caller graph for this function:

remove_first()

Node * remove_first

(

List *

list

)

Remove first node in list.

Parameters

list

Returns

Definition at line 255 of file doublyLinkedList.c.

{
  if (list->size_ == 0)
  {
    return NULL;
  }
 
  Node *removed = list->first_;
  Node *second = list->first_->next_;
  list->first_ = second;
  list->size_--;
  return removed;
}

References _List_::first_, _Node_::next_, and _List_::size_.

removeNodeFromList()

bool removeNodeFromList	(	List *	list,
		Node *	node )

Removes a node from the list.

Parameters

list	Address of the list
node	Address of node which should be removed

Returns

true: could be removed | false: could not be removed

Definition at line 164 of file doublyLinkedList.c.

{
  if (list->size_ == 0)
  {
    return NULL;
  }
 
  if (node->next_ == NULL && node->previous_ == NULL)
  {
    list->first_ = NULL;
    list->last_ = NULL;
    list->size_--;
 
    return true;
  }
  else if (node->next_ == NULL) // Node is the last element in the list
  {
    list->last_ = node->previous_; // Set last list element to the one before this node
    node->previous_->next_ = NULL; // Set the pointer from the second last node to this to NULL
    list->size_--;
 
    return true;
  }
  else if (node->previous_ == NULL) // Node is first element in list
  {
    list->first_ = node->next_;    // Set first list element to the one after this node
    node->next_->previous_ = NULL; // Set the pointer from the second node to this to NULL
    list->size_--;
 
    return true;
  }
  else
  {
    node->next_->previous_ = node->previous_;
    node->previous_->next_ = node->next_;
    list->size_--;
 
    return true;
  }
  return false;
}

References _List_::first_, _List_::last_, _Node_::next_, _Node_::previous_, and _List_::size_.

Referenced by freeList().

Here is the caller graph for this function:

removeNodeWithValue()

Node * removeNodeWithValue	(	List *	list,
		int	data )

Remove a node from a list with a specific value of playing_card_.

Parameters

list	List where the node should be removed
value	Value of playing_card_ that should be removed

Returns

Returns the address of the node that is removed from the list

Definition at line 210 of file doublyLinkedList.c.

{
  Node *current_node = list->first_;
  while (current_node != NULL)
  {
    if (current_node->data_ == data)
    {
      if (current_node == list->first_)
      {
        list->first_ = current_node->next_;
      }
      else
      {
        current_node->previous_->next_ = current_node->next_;
      }
      if (current_node == list->last_)
      {
        list->last_ = current_node->previous_;
      }
      else
      {
        current_node->next_->previous_ = current_node->previous_;
      }
      if(list->first_ != NULL)
      {
        list->first_->previous_ = NULL;
      }
      if(list->last_ != NULL)
      {
        list->last_->next_ = NULL;
      }
      
      list->size_--;
      current_node->previous_ = NULL;
      current_node->next_ = NULL;
      return current_node;
    }
    current_node = current_node->next_;
  }
  return NULL; // value not found
}

References _Node_::data_, _List_::first_, _List_::last_, _Node_::next_, _Node_::previous_, and _List_::size_.