updates

Author: Hysperr

Bag Linked List/CMakeLists.txt

@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 3.7)
+project(Bag_Linked_List)
+
+set(CMAKE_CXX_STANDARD 11)
+
+set(SOURCE_FILES
+    bag_linked_list.cpp
+    bag_linked_list.h
+    main.cpp
+    node.cpp
+    node.h)
+
+add_executable(Bag_Linked_List ${SOURCE_FILES})

Bag Linked List/bag_linked_list.cpp

@@ -0,0 +1,123 @@
+/**
+CLASS implemented: bag_linked_list (see bag_linked_list.h for documentation)
+INVARIANT for the bag ADT:
+1. The items in the bag are stored on a linked list;
+2. The head pointer of the list is stored in the member variable head_ptr;
+3. The total number of items in the list is stored in the member variable
+many_nodes.
+*/
+
+#include <cassert>  // Provides assert
+#include <cstdlib>  // Provides NULL, rand, size_t
+#include "node.h"  // Provides node and the linked list functions
+#include "bag_linked_list.h"
+
+using namespace std;
+
+bag::bag() {
+    head_ptr = nullptr;
+    many_nodes = 0;
+}
+
+bag::bag(const bag &source) {
+    node *tail_ptr;  // Needed for argument of list_copy
+
+    list_copy(source.head_ptr, head_ptr, tail_ptr);
+    many_nodes = source.many_nodes;
+}
+
+bag::~bag() {
+    list_clear(head_ptr);
+    many_nodes = 0;
+}
+
+bag::size_type bag::count(const value_type &target) const {
+    size_type answer = 0;
+    // Use const node* since we don't change the nodes.
+    const node *cursor = list_search(head_ptr, target);
+    while (cursor != nullptr) {
+        // Each time that cursor is not nullptr, we have another occurrence of
+        // target, so we add one to answer, and move cursor to the next
+        // occurrence of the target.
+        ++answer;
+        cursor = cursor->link();
+        cursor = list_search(cursor, target);
+    }
+    return answer;
+}
+
+bag::size_type bag::erase(const value_type &target) {
+    size_type answer = 0;
+    node *target_ptr = list_search(head_ptr, target);
+    while (target_ptr != nullptr) {
+        // Each time that target_ptr is not nullptr, we have another occurrence
+        // of target. We remove this target using the same technique that
+        // was used in erase_one.
+        target_ptr->set_data(head_ptr->data());
+        target_ptr = target_ptr->link();
+        target_ptr = list_search(target_ptr, target);
+        list_head_remove(head_ptr);
+        --many_nodes;
+        ++answer;
+    }
+    return answer;
+}
+
+bool bag::erase_one(const value_type &target) {
+    node *target_ptr;
+
+    target_ptr = list_search(head_ptr, target);
+    if (target_ptr == nullptr)
+        return false; // target isn't in the bag, so no work to do
+    target_ptr->set_data(head_ptr->data());
+    list_head_remove(head_ptr);
+    --many_nodes;
+    return true;
+}
+
+bag::value_type bag::grab() const {
+    size_type i;
+    const node *cursor; // Use const node* since we don't change the nodes.
+
+    assert(size() > 0);
+    i = (rand() % size()) + 1;
+    cursor = list_locate(head_ptr, i);
+    return cursor->data();
+}
+
+void bag::insert(const value_type &entry) {
+    list_head_insert(head_ptr, entry);
+    ++many_nodes;
+}
+
+void bag::operator+=(const bag &addend) {
+    node *copy_head_ptr;
+    node *copy_tail_ptr;
+
+    if (addend.many_nodes > 0) {
+        list_copy(addend.head_ptr, copy_head_ptr, copy_tail_ptr);
+        copy_tail_ptr->set_link(head_ptr);
+        head_ptr = copy_head_ptr;
+        many_nodes += addend.many_nodes;
+    }
+}
+
+void bag::operator=(const bag &source) {
+    node *tail_ptr; // Needed for argument to list_copy
+
+    if (this == &source)
+        return;
+
+    list_clear(head_ptr);
+    many_nodes = 0;
+    list_copy(source.head_ptr, head_ptr, tail_ptr);
+    many_nodes = source.many_nodes;
+}
+
+bag operator+(const bag &b1, const bag &b2) {
+    bag answer;
+
+    answer += b1;
+    answer += b2;
+    return answer;
+}

Bag Linked List/bag_linked_list.h

@@ -0,0 +1,104 @@
+/**
+TYPEDEFS for the bag class:
+bag::value_type
+is the data type of the items in the bag. It may be any
+of the C++ built-in types (int, char, etc.), or a class with a default
+constructor, a copy constructor, an assignment
+operator, and a test for equality (x == y).
+
+bag::size_type
+is the data type of any variable that keeps track of how many items are
+in a bag
+
+CONSTRUCTOR for the bag class:
+bag( )
+Postcondition: The bag is empty.
+
+MODIFICATION MEMBER FUNCTIONS for the bag class:
+size_type erase(const value_type& target)
+Postcondition: All copies of target have been removed from the bag.
+The return value is the number of copies removed (which could be zero).
+
+bool erase_one(const value_type& target)
+Postcondition: If target was in the bag, then one copy of target has
+been removed from the bag; otherwise the bag is unchanged. A true
+return value indicates that one copy was removed; false indicates that
+nothing was removed.
+
+void insert(const value_type& entry)
+Postcondition: A new copy of entry has been inserted into the bag.
+
+void operator +=(const bag& addend)
+Postcondition: Each item in addend has been added to this bag.
+
+CONSTANT MEMBER FUNCTIONS for the bag class:
+size_type size( ) const
+Postcondition: Return value is the total number of items in the bag.
+
+size_type count(const value_type& target) const
+Postcondition: Return value is number of times target is in the bag.
+
+value_type grab( ) const
+Precondition: size( ) > 0.
+Postcondition: The return value is a randomly selected item from the bag.
+
+NONMEMBER FUNCTIONS for the bag class:
+bag operator +(const bag& b1, const bag& b2)
+Postcondition: The bag returned is the union of b1 and b2.
+
+VALUE SEMANTICS for the bag class:
+Assignments and the copy constructor may be used with bag objects.
+
+DYNAMIC MEMORY USAGE by the bag:
+If there is insufficient dynamic memory, then the following functions throw
+bad_alloc: The constructors, insert, operator +=, operator +, and the
+assignment operator.
+*/
+
+#ifndef BAG_LINKED_LIST_H
+#define BAG_LINKED_LIST_H
+
+#include <cstdlib>
+#include "node.h"
+
+class bag {
+
+public:
+
+    typedef std::size_t size_type;
+    typedef node::value_type value_type;
+
+    bag();
+
+    bag(const bag &source);
+
+    ~bag();
+
+    size_type erase(const value_type &target);
+
+    bool erase_one(const value_type &target);
+
+    void insert(const value_type &entry);
+
+    void operator+=(const bag &addend);
+
+    void operator=(const bag &source);
+
+    size_type size() const { return many_nodes; }
+
+    size_type count(const value_type &target) const;
+
+    value_type grab() const;
+
+private:
+
+    node *head_ptr;       // List head pointer
+    size_type many_nodes; // Number of nodes on the list
+
+};
+
+// NONMEMBER FUNCTIONS for the bag class:
+bag operator+(const bag &b1, const bag &b2);
+
+
+#endif

BagwithLinkList/bagLL_demo.cpp Bag Linked List/main.cppBagwithLinkList/bagLL_demo.cpp renamed to Bag Linked List/main.cpp

@@ -1,14 +1,14 @@
-/** FILE: bagLL_demo.cpp
- Demonstration program for the 3rd version of the bag (bag3.h and bag3.cxx).
- This is a the same as the demonstration program for bag1,
- except that we no longer need to check whether the bag reaches its
- capacity.*/
+/**
+Demonstration program for the 3rd version of the bag (bag3.h and bag3.cxx).
+This is a the same as the demonstration program for bag1,
+except that we no longer need to check whether the bag reaches its
+capacity.
+*/
 
-#include <iostream>     // Provides cout and cin
-#include "bag_linked_list.h"       // With Item defined as an int
+#include <iostream>
+#include "bag_linked_list.h"
 
 using namespace std;
-using namespace main_savitch_5;
 
 // PROTOTYPES for functions used by this demonstration program:
 void get_ages(bag &ages);

Bag Linked List/node.cpp

@@ -0,0 +1,102 @@
+/**
+IMPLEMENTS: The functions of the node class and the
+linked list toolkit (see node.h for documentation).
+INVARIANT for the node class:
+The data of a node is stored in data_field, and the link in link_field.
+*/
+
+#include "node.h"
+#include <cassert>
+
+using namespace std;
+
+size_t list_length(const node *head_ptr) {
+    const node *cursor;
+    size_t answer = 0;
+
+    for (cursor = head_ptr; cursor != nullptr; cursor = cursor->link())
+        ++answer;
+
+    return answer;
+}
+
+void list_head_insert(node *&old_head_ptr, const node::value_type &entry) {
+    old_head_ptr = new node(entry, old_head_ptr);
+}
+
+void list_insert(node *previous_ptr, const node::value_type &entry) {
+    node *insert_ptr;
+    insert_ptr = new node(entry, previous_ptr->link());
+    previous_ptr->set_link(insert_ptr);
+}
+
+node *list_search(node *head_ptr, const node::value_type &target) {
+    node *cursor;
+    for (cursor = head_ptr; cursor != nullptr; cursor = cursor->link())
+        if (target == cursor->data())
+            return cursor;
+    return nullptr;
+}
+
+const node *list_search(const node *head_ptr, const node::value_type &target) {
+    const node *cursor;
+    for (cursor = head_ptr; cursor != nullptr; cursor = cursor->link())
+        if (target == cursor->data())
+            return cursor;
+    return nullptr;
+}
+
+node *list_locate(node *head_ptr, size_t position) {
+    assert (position > 0);
+    node *cursor = head_ptr;
+    for (size_t i = 1; (i < position) && (cursor != nullptr); i++)
+        cursor = cursor->link();
+    return cursor;
+}
+
+const node *list_locate(const node *head_ptr, size_t position) {
+    assert (0 < position);
+    const node *cursor = head_ptr;
+    for (size_t i = 1; (i < position) && (cursor != nullptr); i++)
+        cursor = cursor->link();
+    return cursor;
+}
+
+void list_head_remove(node *&head_ptr) {
+    node *remove_ptr = head_ptr;
+    head_ptr = head_ptr->link();
+    delete remove_ptr;
+}
+
+void list_remove(node *previous_ptr) {
+    node *remove_ptr;
+    remove_ptr = previous_ptr->link();
+    previous_ptr->set_link(remove_ptr->link());
+    delete remove_ptr;
+}
+
+void list_clear(node *&head_ptr) {
+    while (head_ptr != nullptr)
+        list_head_remove(head_ptr);
+}
+
+void list_copy(const node *source_ptr, node *&head_ptr, node *&tail_ptr) {
+    head_ptr = nullptr;
+    tail_ptr = nullptr;
+
+    // Handle the case of the empty list.
+    if (source_ptr == nullptr)
+        return;
+
+    // Make the head node for the newly created list, and put data in it.
+    list_head_insert(head_ptr, source_ptr->data());
+    tail_ptr = head_ptr;
+
+    // Copy the rest of the nodes one at a time, adding at the tail of new list.
+    source_ptr = source_ptr->link();
+    while (source_ptr != nullptr) {
+        list_insert(tail_ptr, source_ptr->data());
+        tail_ptr = tail_ptr->link();
+        source_ptr = source_ptr->link();
+    }
+}