Upload New File

list/linked_list.cc

+ 
+ #include "linked_list.h"
+ 
+ 
+ List::List(): 
+    head{nullptr}, tail{nullptr} 
+    {}
+
+    List::List(List const& rhs) :
+        List()
+    {
+        for (int n{ 0 }; n < rhs.get_size(); n++) {
+            Insert_Node(rhs.at(n));
+        }
+    }
+
+    List::List(List&& rhs) :
+        List()
+    {
+        *this = std::move(rhs);
+    }
+
+    List::~List() {
+        while (head != nullptr) {
+            Node* temp = head;
+            head = head->next;
+            delete temp;
+        }
+        tail = nullptr;
+        list_size = 0;
+    }
+
+    bool List::List_Is_Empty(){
+        if (head == nullptr)
+        {
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+
+    int List::get_size()const
+    {
+        return list_size;
+    }
+
+    int List::at(int const& position)const
+    {
+        if (position < get_size())
+        {
+            Node* tmp = head;
+            for (int n = 0; n < position; n++)
+            {
+                tmp = tmp->next;
+            }
+            return tmp->value;
+        }
+        else {
+            throw std::logic_error("fel storlek");
+
+        }
+    }
+
+    List::Node::Node(int insert_value):
+    value{insert_value}
+    {}
+
+//omskriven insert funktion SOM INTE ÄR TESTAD 
+
+void List::Insert_Node(int insert_value) {
+    if (List_Is_Empty()) {
+        Node* my_node = new Node(insert_value);
+        head = my_node;
+        tail = my_node;
+    }
+    else {
+        Node* tmp = head;
+        while (tmp->next != nullptr && insert_value >= tmp->value) {
+            tmp = tmp->next;
+        }
+        if (insert_value > tmp->value) {
+            Node* my_node = new Node(insert_value);
+            my_node->next = tmp->next;
+            my_node->previous = tmp;
+            if (tmp->next != nullptr) {
+                tmp->next->previous = my_node;
+            }
+            else {
+                tail = my_node;
+            }
+            tmp->next = my_node;
+        }
+        else {
+            Node* my_node = new Node(insert_value);
+            my_node->next = tmp;
+            my_node->previous = tmp->previous;
+            if (tmp->previous != nullptr) {
+                tmp->previous->next = my_node;
+            }
+            else {
+                head = my_node;
+            }
+            tmp->previous = my_node;
+        }
+    }
+    list_size++;
+}
+
+
+void List::remove(int const& pos) {
+        Node* tmp = head;
+
+        for (int n = pos; n > 0; n--) {
+            tmp = tmp->next;
+        }
+
+        if (tmp->previous == nullptr && tmp->next == nullptr) {
+            delete tmp;
+            head = nullptr;
+            tail = nullptr;
+
+        }
+        else if (tmp->next == nullptr) {
+            tail = tmp->previous;
+            tail->next = nullptr;
+            delete tmp;
+        }
+        else if (tmp->previous == nullptr) {
+            head = tmp->next;
+            head->previous = nullptr;
+            delete tmp;
+        }
+        else {
+            tmp->previous->next = tmp->next;
+            delete tmp;
+        }
+        list_size--;
+}
+
+int List::get_size()
+{
+    return list_size;
+
+}
+
+//fixa argument 
+List::List(std::initializer_list<int> const &list)
+{
+    List();
+    for (int n: list){
+        Insert_Node(n);
+       }
+}
+
+List& List::operator =(List const& rhs)
+{
+    int tmp = get_size();
+    for (int k{ tmp }; k > 0; k--)
+    {
+        remove(0);
+    }
+
+    for (int n{ 0 }; n < rhs.get_size(); n++) {
+        Insert_Node(rhs.at(n));
+    }
+
+    list_size = rhs.get_size();
+
+    return *this;
+}
+
+List& List::operator =(List&& rhs) //FLyttilldelning
+{
+
+    Node* tmp_head = head;
+    Node* tmp_tail = tail;
+
+    int tmp_size = get_size();
+    list_size = rhs.get_size();
+    rhs.list_size = tmp_size;
+
+    head = rhs.head;
+    tail = rhs.tail;
+
+    rhs.head = tmp_head;
+    rhs.tail = tmp_tail;
+
+    return *this;
+}
+
+ostream& operator << (ostream& os, List const& rhs)
+{   
+    for (int n{ 0 }; n < rhs.get_size(); n++)
+    {
+        os << rhs.at(n);
+        if (n + 1 != rhs.get_size()) {
+            os << " ";
+        }
+    }
+    return os;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+ /*void List::printlist(Node* head){
+Node* traverser = head;
+while(traverser != nullptr) {
+    cout<<traverser->value<<endl;
+    traverser = traverser->next; 
+}
+}
+*/
+
+/*int main()
+
+{
+
+List newlist;
+
+
+newlist.Insert_Node(1);
+newlist.Insert_Node(2);
+newlist.Insert_Node(3);
+
+newlist.printlist(newlist.head);
+
+return 0;
+}*/
\ No newline at end of file