operations_on_datastructures::circular_linked_list::CircularLinkedList Class Reference

A class that implements a Circular Linked List. More...

Collaboration diagram for operations_on_datastructures::circular_linked_list::CircularLinkedList:

Public Member Functions
	CircularLinkedList ()
	Creates an empty CircularLinkedList.
	CircularLinkedList (const CircularLinkedList &copy)
	Copy constructor for CircularLinkedList.
	CircularLinkedList (CircularLinkedList &&source) noexcept
	Move constructor for CircularLinkedList.
CircularLinkedList &	operator= (const CircularLinkedList &other)
	Copy assignment operator.
CircularLinkedList &	operator= (CircularLinkedList &&other) noexcept
	Move assignment operator.
	~CircularLinkedList ()
	Cleans up memory when destroyed.
void	erase ()
void	insert (const std::vector< int64_t > &values)
	Inserts all the values from a vector into the Circular Linked List.
void	insert (int64_t data)
	Inserts a single value into the Circular Linked List.
void	insert (Node *node)
	Inserts a given Node into the Circular Linked List.
void	print ()
	Prints the values of the Circular Linked List, beginning from the root Node.
void	print (Node *root)
	Prints the values of the Circular Linked List, beginning from a given Node to be used as the root.
std::vector< int64_t >	values ()
	Returns a std::vector of the values of the Circular Linked List.
std::vector< int64_t >	values (Node *root)
	Returns a std::vector of the values of the Circular Linked List, beginning from a given Node.

Private Attributes
Node *	root
	Pointer to the root Node.
Node *	end {}
	Pointer to the last Node.

Detailed Description

A class that implements a Circular Linked List.

Definition at line 57 of file circular_linked_list.cpp.

Constructor & Destructor Documentation

CircularLinkedList() [1/3]

operations_on_datastructures::circular_linked_list::CircularLinkedList::CircularLinkedList ( )

inline

Creates an empty CircularLinkedList.

Definition at line 66 of file circular_linked_list.cpp.

                         {
        root = nullptr;
        end = nullptr;
    }

CircularLinkedList() [2/3]

operations_on_datastructures::circular_linked_list::CircularLinkedList::CircularLinkedList ( const CircularLinkedList & copy )

inline

Copy constructor for CircularLinkedList.

Definition at line 73 of file circular_linked_list.cpp.

                                                       {
        erase();
        root = nullptr;
        Node* node = copy.root;
        while (node != nullptr) {
            insert(node->data);
            node = node->next;
        }
    }

CircularLinkedList() [3/3]

operations_on_datastructures::circular_linked_list::CircularLinkedList::CircularLinkedList ( CircularLinkedList && source )

inlinenoexcept

Move constructor for CircularLinkedList.

Parameters

source

rvalue reference to a Circular Linked List

Definition at line 86 of file circular_linked_list.cpp.

                                                             {
        root = source.root;
        end = source.end;
        source.root = nullptr;
        source.end = nullptr;
    }

~CircularLinkedList()

operations_on_datastructures::circular_linked_list::CircularLinkedList::~CircularLinkedList ( )

inline

Cleans up memory when destroyed.

Definition at line 122 of file circular_linked_list.cpp.

{ erase(); }

Member Function Documentation

erase()

void operations_on_datastructures::circular_linked_list::CircularLinkedList::erase ( )

inline

Iteratively frees each node in the Circular Linked List from the heap

Definition at line 126 of file circular_linked_list.cpp.

                 {
        if (root == nullptr) {
            return;
        }
        Node* node = root;
        do {
            Node* temp = node;
            node = node->next;
            delete (temp);
        } while (node != root);
        root = nullptr;
        end = nullptr;
    }

insert() [1/3]

void operations_on_datastructures::circular_linked_list::CircularLinkedList::insert ( const std::vector< int64_t > & values )

inline

Inserts all the values from a vector into the Circular Linked List.

Goes through each element in the vector sequentially, inserting it into the list

Parameters

values

The vector of integer values that is to be inserted

Returns

void

Definition at line 146 of file circular_linked_list.cpp.

                                                  {
        for (int64_t value : values) {
            insert(value);
        }
    }

insert() [2/3]

void operations_on_datastructures::circular_linked_list::CircularLinkedList::insert ( int64_t data )

inline

Inserts a single value into the Circular Linked List.

Creates a Node with the given value, pointing to the root Node and inserts it into the list

Parameters

data	The integer valus to be inserted

Returns

void

Definition at line 158 of file circular_linked_list.cpp.

                              {
        Node* node = new Node(data, root);
        insert(node);
    }

insert() [3/3]

void operations_on_datastructures::circular_linked_list::CircularLinkedList::insert ( Node * node )

inline

Inserts a given Node into the Circular Linked List.

Checks wheter the list is empty, and inserts the Node, modifying the end pointer

Parameters

node	The Node that is to be inserted

Returns

void

< Set node as the root

< Point node to itself

< Set the end to the root

< Append node to the end

< Set the next value to the root

< Make end point to node

Definition at line 169 of file circular_linked_list.cpp.

                            {
        if (root == nullptr) {
            root = node;        
            node->next = root;  
            end = root;         
        } else {
            end->next = node;   
            node->next = root;  
            end = node;         
        }
    }

operator=() [1/2]

CircularLinkedList & operations_on_datastructures::circular_linked_list::CircularLinkedList::operator= ( CircularLinkedList && other )

inlinenoexcept

Move assignment operator.

Parameters

other

rvalue reference to a Circular Linked List

Returns

Reference to CircularLinkedList

Definition at line 112 of file circular_linked_list.cpp.

                                                                       {
        root = other.root;
        end = other.end;
        other.root = nullptr;
        other.end = nullptr;
        return *this;
    }

operator=() [2/2]

CircularLinkedList & operations_on_datastructures::circular_linked_list::CircularLinkedList::operator= ( const CircularLinkedList & other )

inline

Copy assignment operator.

Parameters

other

Reference to a Circular Linked List

Returns

Reference to CircularLinkedList

Definition at line 97 of file circular_linked_list.cpp.

                                                                   {
        erase();
        root = nullptr;
        Node* node = other.root;
        while (node != nullptr) {
            insert(node->data);
            node = node->next;
        }
        return *this;
    }

print() [1/2]

void operations_on_datastructures::circular_linked_list::CircularLinkedList::print ( )

inline

Prints the values of the Circular Linked List, beginning from the root Node.

Goes through each Node from the root and prints them out in order

Returns

void

Definition at line 187 of file circular_linked_list.cpp.

{ print(root); }

print() [2/2]

void operations_on_datastructures::circular_linked_list::CircularLinkedList::print ( Node * root )

inline

Prints the values of the Circular Linked List, beginning from a given Node to be used as the root.

Goes through each Node from the given Node and prints them out in order. If the list is empty, it prints the message 'Empty List!'

Parameters

root	The Node to start at

Returns

void

Definition at line 196 of file circular_linked_list.cpp.

                           {
        Node* temp = root;
        if (root == nullptr) {
            std::cout << "Empty List!\n";
            return;
        }
        do {
            std::cout << temp->data << " ";
            temp = temp->next;
        } while (temp != root);
        std::cout << "\n";
    }

values() [1/2]

std::vector< int64_t > operations_on_datastructures::circular_linked_list::CircularLinkedList::values ( )

inline

Returns a std::vector of the values of the Circular Linked List.

Starting from the root Node, appends each value of the list to a std::vector and returns it

Returns

A std::vector of the list's values

Definition at line 214 of file circular_linked_list.cpp.

{ return values(root); }

values() [2/2]

std::vector< int64_t > operations_on_datastructures::circular_linked_list::CircularLinkedList::values ( Node * root )

inline

Returns a std::vector of the values of the Circular Linked List, beginning from a given Node.

Starting from a given Node, appends each value of the list to a std::vector and returns it

Parameters

root	The Node to start at

Returns

A std::vector of the list's values

< Return empty vector

Definition at line 223 of file circular_linked_list.cpp.

                                          {
        std::vector<int64_t> res;
        if (root == nullptr) {
            return res;  
        }
        Node* temp = root;
        do {
            res.push_back(temp->data);
            temp = temp->next;
        } while (temp != root);
        return res;
    }

Member Data Documentation

end

Node* operations_on_datastructures::circular_linked_list::CircularLinkedList::end {}

private

Pointer to the last Node.

Definition at line 60 of file circular_linked_list.cpp.

{};  

root

Node* operations_on_datastructures::circular_linked_list::CircularLinkedList::root

private

Pointer to the root Node.

Definition at line 59 of file circular_linked_list.cpp.

---

The documentation for this class was generated from the following file:

• operations_on_datastructures/circular_linked_list.cpp