C++

// FILE: node1.h // PROVIDES: A class for a node in a linked list, and list manipulation // functions, all within the namespace main_savitch_5 // // TYPEDEF for the node class: // Each node of the list contains a piece of data and a pointer to the // next node. The type of the data is defined as node::value_type in a // typedef statement. The value_type may be any // of the built-in C++ classes (int, char, ...) or a class with a copy // constructor, an assignment operator, and a test for equality (x == y). // // CONSTRUCTOR for the node class: // node( // const value_type& init_data = value_type(), // node* init_link = NULL // ) // Postcondition: The node contains the specified data and link. // NOTE: The default value for the init_data is obtained from the default // constructor of the value_type. In the ANSI/ISO standard, this notation // is also allowed for the built-in types, providing a default value of // zero. The init_link has a default value of NULL. // // NOTE: // Some of the functions have a return value which is a pointer to a node. // Each of these functions comes in two versions: a non-const version (where // the return value is node*) and a const version (where the return value // is const node*). // EXAMPLES: // const node *c; // c->link( ) activates the const version of link // list_search(c,... calls the const version of list_search // node *p; // p->link( ) activates the non-const version of link // list_search(p,... calls the non-const version of list_search // // MEMBER FUNCTIONS for the node class: // void set_data(const value_type& new_data) // Postcondition: The node now contains the specified new data. // // void set_link(node* new_link) // Postcondition: The node now contains the specified new link. // // value_type data( ) const // Postcondition: The return value is the data from this node. // // const node* link( ) const  0. // Postcondition: The pointer returned points to the node at the specified // position in the list. (The head node is position 1, the next node is // position 2, and so on). If there is no such position, then the null // pointer is returned. // // void list_head_remove(node*& head_ptr) // Precondition: head_ptr is the head pointer of a linked list, with at // least one node. // Postcondition: The head node has been removed and returned to the heap; // head_ptr is now the head pointer of the new, shorter linked list. // // void list_remove(node* previous_ptr) // Precondition: previous_ptr points to a node in a linked list, and this // is not the tail node of the list. // Postcondition: The node after previous_ptr has been removed from the // linked list. // // void list_clear(node*& head_ptr) // Precondition: head_ptr is the head pointer of a linked list. // Postcondition: All nodes of the list have been returned to the heap, // and the head_ptr is now NULL. // // void list_copy(const node* source_ptr, node*& head_ptr, node*& tail_ptr) // Precondition: source_ptr is the head pointer of a linked list. // Postcondition: head_ptr and tail_ptr are the head and tail pointers for // a new list that contains the same items as the list pointed to by // source_ptr. The original list is unaltered. // void list_piece( // const node* start_ptr, const node* end_ptr, // node*& head_ptr, node*& tail_ptr // ) // Precondition: start_ptr and end_ptr are pointers to nodes on the same // linked list, with the start_ptr node at or before the end_ptr node // Postcondition: head_ptr and tail_ptr are the head and tail pointers for a // new list that contains the items from start_ptr up to but not including // end_ptr. The end_ptr may also be NULL, in which case the new list // contains elements from start_ptr to the end of the list. // // DYNAMIC MEMORY usage by the toolkit: // If there is insufficient dynamic memory, then the following functions throw // bad_alloc: the constructor, list_head_insert, list_insert, list_copy, // list_piece. #ifndef MAIN_SAVITCH_NODE1_H #define MAIN_SAVITCH_NODE1_H #include  // Provides size_t and NULL namespace main_savitch_5 { class node { public: // TYPEDEF typedef double value_type; // CONSTRUCTOR node( const value_type& init_data = value_type( ), node* init_link = NULL ) { data_field = init_data; link_field = init_link; } // Member functions to set the data and link fields: void set_data(const value_type& new_data) { data_field = new_data; } void set_link(node* new_link) { link_field = new_link; } // Constant member function to retrieve the current data: value_type data( ) const { return data_field; } // Two slightly different member functions to retreive // the current link: const node* link( ) const { return link_field; } node* link( ) { return link_field; } private: value_type data_field; node* link_field; }; // FUNCTIONS for the linked list toolkit std::size_t list_length(const node* head_ptr); void list_head_insert(node*& head_ptr, const node::value_type& entry); void list_insert(node* previous_ptr, const node::value_type& entry); node* list_search(node* head_ptr, const node::value_type& target); const node* list_search (const node* head_ptr, const node::value_type& target); node* list_locate(node* head_ptr, std::size_t position); const node* list_locate(const node* head_ptr, std::size_t position); void list_head_remove(node*& head_ptr); void list_remove(node* previous_ptr); void list_clear(node*& head_ptr); void list_copy(const node* source_ptr, node*& head_ptr, node*& tail_ptr); } #endif

// FILE: node1.cxx // IMPLEMENTS: The functions of the node class and the // linked list toolkit (see node1.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 "node1.h" #include  // Provides assert #include  // Provides NULL and size_t using namespace std; namespace main_savitch_5 { size_t list_length(const node* head_ptr) // Library facilities used: cstdlib { const node *cursor; size_t answer; answer = 0; for (cursor = head_ptr; cursor != NULL; cursor = cursor->link( )) ++answer; return answer; } void list_head_insert(node*& head_ptr, const node::value_type& entry) { head_ptr = new node(entry, 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) // Library facilities used: cstdlib { node *cursor; for (cursor = head_ptr; cursor != NULL; cursor = cursor->link( )) if (target == cursor->data( )) return cursor; return NULL; } const node* list_search(const node* head_ptr, const node::value_type& target) // Library facilities used: cstdlib { const node *cursor; for (cursor = head_ptr; cursor != NULL; cursor = cursor->link( )) if (target == cursor->data( )) return cursor; return NULL; } node* list_locate(node* head_ptr, size_t position) // Library facilities used: cassert, cstdlib { node *cursor; size_t i; assert (0 link( ); return cursor; } const node* list_locate(const node* head_ptr, size_t position) // Library facilities used: cassert, cstdlib { const node *cursor; size_t i; assert (0 link( ); return cursor; } void list_head_remove(node*& head_ptr) { node *remove_ptr; 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) // Library facilities used: cstdlib { while (head_ptr != NULL) list_head_remove(head_ptr); } void list_copy(const node* source_ptr, node*& head_ptr, node*& tail_ptr) // Library facilities used: cstdlib { head_ptr = NULL; tail_ptr = NULL; // Handle the case of the empty list. if (source_ptr == NULL) 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 != NULL) { list_insert(tail_ptr, source_ptr->data( )); tail_ptr = tail_ptr->link( ); source_ptr = source_ptr->link( ); } } }

Part 1 (20 points): 1. Download and compile files nodel.h and node1.cpp. provided in the authors' website. 2. Write small interactive test program (call it and save it in file node1_Test.cpp) to test class nodel. The test program creates a linked list of doubles (say grades) and allows the user to call any of the linked list functions implement in class node1 on the grades list. To make the test program more friendly, use a menu to display the linked list functions to the user, similar to what we did in the previous assignments. Part 1 (80 points): 1. Now, expand class node1 to include three more linked list functions defined as follows. (create 2 new files named node1_New.h and node1_New.cpp) a. Function delete_reps () that deletes all repeated values from the linked list. The function returns a new linked list without repeated values. The original linked list is preserved as is. Thus, this function involves copying nodes to the new linked list. b. Function sort_list() that takes a linked list and sorts it in ascending order (smallest to largest) using selection sort algorithm (see below). The list may include repeated values. The function prototype would be void sort_list((node*& head_ptr); Selection sort for this exercise works as follows: Loop through the entire original list (while list has more nodes) Begin 1. Find the node with the largest value in the original list. 2. Remove the node from the original list. 3. Insert the node at the head of the target list. End; Notice the following: after all nodes are moved to the target list, pointer head_ptr needs to point to the head node of the target list; when the loop is done, the original list should be empty due to the removal of node to the target list; and the function does not need to allocate any memory space (i.e., using the new operator). C. Function split_list() that take a specific value in the list (say split_value) and splits the list into 2 linked lists. First linked list contains all values before the split_value; and the second list contains all the values from the first instance of the split_value and beyond. For example, if List1 = {1, 8, 4, 7, 2, 3, 6, 8, 2, 3, 4, 6, 9} and the split value is 3, then the result would be as follows: List1 = {1, 8, 4,7, 2} List2 = {3, 6, 8, 2, 3, 4, 9} For uniformity, let's assume that the first list is called List1 and the second list is called List2. Note that if the split value is repeated in the linked list, we split the list at the first instance of the split value. Let's also assume that we persevere the original list as is. That is, List1 is the original list name. 2. Copy your test file from part 1 and name it node1_New_Test.cpp. Modify the new test program menu to include the newly added functions. The new test program still creates a linked list of integers (say grades). Allow the user to call any of the linked list functions implement in class node1_New on the grades list. Test your code with different list of different lengths and make sure you test the code with both invalid (bad) and valid (good) data. Always test code with an empty linked list first. Part 1 (20 points): 1. Download and compile files nodel.h and node1.cpp. provided in the authors' website. 2. Write small interactive test program (call it and save it in file node1_Test.cpp) to test class nodel. The test program creates a linked list of doubles (say grades) and allows the user to call any of the linked list functions implement in class node1 on the grades list. To make the test program more friendly, use a menu to display the linked list functions to the user, similar to what we did in the previous assignments. Part 1 (80 points): 1. Now, expand class node1 to include three more linked list functions defined as follows. (create 2 new files named node1_New.h and node1_New.cpp) a. Function delete_reps () that deletes all repeated values from the linked list. The function returns a new linked list without repeated values. The original linked list is preserved as is. Thus, this function involves copying nodes to the new linked list. b. Function sort_list() that takes a linked list and sorts it in ascending order (smallest to largest) using selection sort algorithm (see below). The list may include repeated values. The function prototype would be void sort_list((node*& head_ptr); Selection sort for this exercise works as follows: Loop through the entire original list (while list has more nodes) Begin 1. Find the node with the largest value in the original list. 2. Remove the node from the original list. 3. Insert the node at the head of the target list. End; Notice the following: after all nodes are moved to the target list, pointer head_ptr needs to point to the head node of the target list; when the loop is done, the original list should be empty due to the removal of node to the target list; and the function does not need to allocate any memory space (i.e., using the new operator). C. Function split_list() that take a specific value in the list (say split_value) and splits the list into 2 linked lists. First linked list contains all values before the split_value; and the second list contains all the values from the first instance of the split_value and beyond. For example, if List1 = {1, 8, 4, 7, 2, 3, 6, 8, 2, 3, 4, 6, 9} and the split value is 3, then the result would be as follows: List1 = {1, 8, 4,7, 2} List2 = {3, 6, 8, 2, 3, 4, 9} For uniformity, let's assume that the first list is called List1 and the second list is called List2. Note that if the split value is repeated in the linked list, we split the list at the first instance of the split value. Let's also assume that we persevere the original list as is. That is, List1 is the original list name. 2. Copy your test file from part 1 and name it node1_New_Test.cpp. Modify the new test program menu to include the newly added functions. The new test program still creates a linked list of integers (say grades). Allow the user to call any of the linked list functions implement in class node1_New on the grades list. Test your code with different list of different lengths and make sure you test the code with both invalid (bad) and valid (good) data. Always test code with an empty linked list first