Pushar

list/linked_list.cc

 #include "linked_list.h"
-/*
+
+    //List::Node::Node(int new_value):
+    //value{new_value}
+    //{}
+
+//omskriven insert funktion SOM INTE ÄR TESTAD 
+
     List::List(): 
     head{nullptr}, tail{nullptr} 
     {}
- 
-    List::~List() {
-    
-    if(List_Is_Empty() == false ){
 
-    Node* my_node = head;
+    List::List(List const& rhs) :
+        List()
+    {
+        for (int i{ 0 }; i < rhs.get_size(); i++) {
+            Insert_Node(rhs.at(i));
+        }
+    }
 
-    while (my_node != tail){
-        my_node = my_node->next;
-        delete my_node->previous;
+    List::List(List&& rhs) :
+        List()
+    {
+        *this = std::move(rhs);
     }
-    delete my_node;
-    head = nullptr;
-    tail = nullptr;
-    list_size = 0; 
 
-}
-}
+    List::~List() {
+        while (head != nullptr) {
+            Node* temp = head;
+            head = head->next;
+            delete temp;
+        }
+        tail = nullptr;
+        list_size = 0;
+    }
 
-     bool List::List_Is_Empty(){
+    bool List::List_Is_Empty(){
         if (head == nullptr)
         {
             return true;
@@ -33,295 +45,181 @@
         }
     }
 
-
-    //List::Node::Node(int new_value):
-   // value{new_value}
-    //{}
-    
-    
-
-
-
-
-//omskriven insert funktion SOM INTE ÄR TESTAD 
-
-
-    void List::Insert_Head_Node(int value){
-
-    
-
-
-    }
-
-    if(List_Is_Empty() == true ){
- 
-    Node* my_node = new Node(value);
-    my_node->previous = nullptr;
-    my_node->next = nullptr;
-    head = my_node;
-    tail = my_node;
+    int List::get_size()const
+    {
+        return list_size;
     }
-    else
-    { 
-    Node* my_node = new Node(value);
-    my_node->previous = tail;
-    my_node->next = nullptr;
-    tail->next = my_node;
-    tail = my_node;
 
+    int List::at(int const& position)const
+    {
+        if (position < get_size())
+        {
+            Node* tmp = head;
+            for (int i = 0; i < position; i++)
+            {
+                tmp = tmp->next;
+            }
+            return tmp->value;
+        }
+        else {
+            throw std::logic_error("Större än listan");
 
-    }
+        }
     }
 
-*/
+    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;
+            }
+            Node* my_node = new Node(insert_value);
+            if (insert_value < tmp->value) {
+                my_node->next = head;
+                my_node->previous = nullptr;
+                head->previous = my_node; // Update previous node's pointer
+                head = my_node;
+            }
+            else if (insert_value > tail->value) {
+                my_node->previous = tail;
+                tail->next = my_node;
+                tail = my_node;
+            }
+            else {
+                my_node->next = tmp;
+                my_node->previous = tmp->previous;
+                tmp->previous->next = my_node;
+                tmp->previous = my_node;
+            }
+        }
+        list_size++;
+    }
 
 
+void List::remove(int const& pos) {
+        Node* tmp = head;
 
-  /**  void List::Insert_Head_Node(int value){
-    Node* my_node = new Node(value);
-    my_node->previous = nullptr;
-    my_node->next = nullptr;
-    head = my_node;
-    tail = my_node;
-    }
+        for (int i = pos; i > 0; i--) {
+            tmp = tmp->next;
+        }
 
-    //insert node at tail 
+        if (tmp->previous == nullptr && tmp->next == nullptr) {
+            delete tmp;
+            head = nullptr;
+            tail = nullptr;
 
-void List::Insert_Tail_Node(int value){
-Node* my_node = new Node(value);
-my_node->previous = tail;
-my_node->next = nullptr;
-tail->next = my_node;
-tail = my_node;
+        }
+        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;
 
-void List::printlist(Node* head){
-Node* traverser = head;
-while(traverser != nullptr) {
-    cout<<traverser->value<<endl;
-    traverser = traverser->next; 
-}
 }
 
-
-int main()
-
+//fixa argument 
+List::List(std::initializer_list<int> const &list)
 {
-
-List newlist;
-
-newlist.Insert_Head_Node(5);
-newlist.Insert_Tail_Node(3);
-newlist.Insert_Tail_Node(1);
-
-newlist.printlist(newlist.head);
-
-return 0;
+    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 i{ 0 }; i < rhs.get_size(); i++) {
+        Insert_Node(rhs.at(i));
+    }
 
+    list_size = rhs.get_size();
 
-    List::Node* Head;
-    List::Node* Tail;
-  
-   
-    List::Node* node = new List::Node();
-    node->Value = 1;
-    node->previous = nullptr;
-    node->next = nullptr;
-    Head = node;
-    Tail = node;
-
-*/
-
-
-
-
-
-
-/*void printlist(List::Node*Head){
-List::Node* Traverser = Head;
-while(Traverser != nullptr) {
-    cout<<Traverser->Value<<endl;
-    Traverser = Traverser->next; 
+    return *this;
 }
 
-
-
-int main()
+List& List::operator =(List&& rhs) //FLyttilldelning
 {
-    Link* Head;
-    Link* Tail;
-
-    
-//Insert node at head
-    Link* link = new Link();
-    link->Value = 1;
-    link->previous = nullptr;
-    link->next = nullptr;
-    Head = link;
-    Tail = link;
-insert node at tail 
-    link = new Link();
-    link->Value = 1;
-    link->previous = Tail;
-    link->next = nullptr;
-    Tail->next = link;
-    Tail = link;
-// node 3 (same as node 2)
-    link = new Link();
-    link->Value = 1;
-    link->previous = Tail;
-    link->next = nullptr;
-    Tail->next = link;
-    Tail = link;
-
-printlist(Head);
-
-}*/
 
-    List::List(): 
-    head{nullptr}, tail{nullptr} 
-    {}
+    Node* tmp_head = head;
+    Node* tmp_tail = tail;
 
-   
-   
-    List::~List() {
-    
-    if(List_Is_Empty() == false ){
+    int tmp_size = get_size();
+    list_size = rhs.get_size();
+    rhs.list_size = tmp_size;
 
-    Node* my_node = head;
+    head = rhs.head;
+    tail = rhs.tail;
 
-    while (my_node != tail){
-        my_node = my_node->next;
-        delete my_node->previous;
-    }
-    delete my_node;
-    head = nullptr;
-    tail = nullptr;
-    list_size = 0; 
+    rhs.head = tmp_head;
+    rhs.tail = tmp_tail;
 
+    return *this;
 }
-}
-
-
-    bool List::List_Is_Empty(){
-        if (head == nullptr)
-        {
-            return true;
-        }
-        else
-        {
-            return false;
-        }
-    }
-
-
-    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;
 
-    }
-    Node* my_node = new Node(insert_value);
-    if (insert_value < tmp->value)
-    {
-    
-    my_node->next = head;
-    my_node->previous = nullptr;
-    head = my_node; 
-    } else if (insert_value > tail->value)
+ostream& operator << (ostream& os, List const& rhs)
+{   
+    for (int i{ 0 }; i < rhs.get_size(); i++)
     {
-        tail = my_node;
-        my_node->previous = tail;
-        tail->next = my_node;
-    
-   
-    } else {
-        my_node->next = tmp;
-        my_node->previous = tmp->previous;
-        tmp->previous->next = my_node;
-        tmp->previous = my_node;
-        
-
-   
-
-    }
+        os << rhs.at(i);
+        if (i + 1 != rhs.get_size()) {
+            os << " ";
+        }
     }
-
-   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);
-}
+    return os;
 }
 
-
 //copy list konstruktor fixa argument 
 //List::Copy_List(List)
 //List()
 
-
-
-
- void List::printlist(Node* head){
-Node* traverser = head;
-while(traverser != nullptr) {
-    cout<<traverser->value<<endl;
-    traverser = traverser->next; 
-}
+void List::printlist(){
+    Node* traverser = head;
+    while(traverser != nullptr) {
+        cout << traverser->value << endl;
+        traverser = traverser->next; 
+    }
 }
-
-
+/*
 int main()
-
 {
+    List newlist{3, 5, 7, 11, 13};
 
-List newlist;
-
-
-newlist.Insert_Node(1);
-newlist.Insert_Node(2);
-newlist.Insert_Node(3);
-
-
-
-
-
-newlist.printlist(newlist.head);
+    newlist.remove(4);
+    newlist.printlist();
 
 return 0;
-}
\ No newline at end of file
+}
+*/
\ No newline at end of file

list/linked_list.h

+#ifndef LINKED_LIST_H
+#define LINKED_LIST_H
+
 #include<iostream>
 using namespace std;
 
-
-
-
-
 class List {
 public:
 
 List();
-~List();
 List(std::initializer_list<int> const &list);
-//void Insert_Head_Node(int value);
+List(List const& rhs);
+List(List&& rhs);
+~List();
+
+int at(int const& i) const;
+void remove(int const& pos);
+int get_size()const;
 void Insert_Node(int insert_value);
 bool List_Is_Empty();
-
-
+List& operator =(List const& rhs);
+List& operator =(List&& rhs);
 
 class Node {
 public:
@@ -30,9 +34,10 @@ public:
 Node* head{nullptr};
 Node* tail{nullptr};
 int list_size {};
-void printlist(Node* head);
+void printlist();
 int get_size();
-
 };
 
+std::ostream& operator << (std::ostream& os, List const& rhs);
 
+#endif
\ No newline at end of file

list/test_main.cc

+#define CATCH_CONFIG_RUNNER
+#include "catch.hpp"
+
+int main(int argc, char* argv[])
+{
+    return Catch::Session{}.run(argc, argv);
+}