#include #include #include "llcpInt.h" using namespace std; // definition of DelOddCopEven of Assignment 5 Part 1 // (put at near top to facilitate printing and grading) //Algorithm should:  /*NOT destroy any of the originally even-valued node.      This means that the originally even-valued nodes should be retained as part of the resulting list.     Destroy ONLY nodes that are originally odd-valued.     Create new nodes and copy data between nodes ONLY when duplicating originally even-valued nodes.     Only ONE new node should be created for each originally even-valued node.     Creating pointer-to-node's (to provide temporary storage for node addresses) does not constitute creating new nodes or copying of items.     NOT make any temporary copies of any of the data items (using any kind of data structures including but not limited to arrays, linked lists and trees).     This means that the algorithm should largely involve the manipulation of pointers.     Function must be iterative (NOT recursive) - use only looping construct(s), without the function calling itself (directly or indirectly).     Function should not call any other functions to help in performing the task. */

Database System Concepts
7th Edition
ISBN:9780078022159
Author:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan
Publisher:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan
Chapter1: Introduction
Section: Chapter Questions
Problem 1PE
icon
Related questions
Question

#include <iostream>
#include <cstdlib>
#include "llcpInt.h"
using namespace std;

// definition of DelOddCopEven of Assignment 5 Part 1
// (put at near top to facilitate printing and grading)
//Algorithm should: 
/*NOT destroy any of the originally even-valued node. 
    This means that the originally even-valued nodes should be retained as part of the resulting list.
    Destroy ONLY nodes that are originally odd-valued.
    Create new nodes and copy data between nodes ONLY when duplicating originally even-valued nodes.
    Only ONE new node should be created for each originally even-valued node.
    Creating pointer-to-node's (to provide temporary storage for node addresses) does not constitute creating new nodes or copying of items.
    NOT make any temporary copies of any of the data items (using any kind of data structures including but not limited to arrays, linked lists and trees).
    This means that the algorithm should largely involve the manipulation of pointers.
    Function must be iterative (NOT recursive) - use only looping construct(s), without the function calling itself (directly or indirectly).
    Function should not call any other functions to help in performing the task.
*/

#ifndef LLCP_INT_H
#define LLCP_INT_H

#include <iostream>

struct Node
{
   int data;
   Node *link;
};

bool    DelOddCopEven(Node* headPtr);
int    FindListLength(Node* headPtr);
bool   IsSortedUp(Node* headPtr);
void   InsertAsHead(Node*& headPtr, int value);
void   InsertAsTail(Node*& headPtr, int value);
void   InsertSortedUp(Node*& headPtr, int value);
bool   DelFirstTargetNode(Node*& headPtr, int target);
bool   DelNodeBefore1stMatch(Node*& headPtr, int target);
void   ShowAll(std::ostream& outs, Node* headPtr);
void   FindMinMax(Node* headPtr, int& minValue, int& maxValue);
double FindAverage(Node* headPtr);
void   ListClear(Node*& headPtr, int noMsg = 0);

// prototype of DelOddCopEven of Assignment 5 Part 1  #endif

================================
passed test on empty list
================================
test case 1 of 1000000
initial: 6  7  5  3  
ought2b: 6  6  
outcome: 6  6  
================================
test case 2 of 1000000
initial: 6  2  9  1  2  7  
ought2b: 6  6  2  2  2  2  
outcome: 6  6  2  2  2  2  
================================
test case 3 of 1000000
initial: 9  
ought2b: 
outcome: 
================================
test case 4 of 1000000
initial: 6  0  6  2  
ought2b: 6  6  0  0  6  6  2  2  
outcome: 6  6  0  0  6  6  2  2  
================================
test case 5 of 1000000
initial: 1  8  7  9  2  0  2  
ought2b: 8  8  2  2  0  0  2  2  
outcome: 8  8  2  2  0  0  2  2  
================================
test case 40000 of 1000000
initial: 5  5  1  
ought2b: 
outcome: 
================================
test case 80000 of 1000000
initial: 2  
ought2b: 2  2  
outcome: 2  2  
================================
test case 120000 of 1000000
initial: 4  4  1  8  
ought2b: 4  4  4  4  8  8  
outcome: 4  4  4  4  8  8  
================================
test case 160000 of 1000000
initial: 0  4  6  
ought2b: 0  0  4  4  6  6  
outcome: 0  0  4  4  6  6  
================================
test case 200000 of 1000000
initial: 1  7  0  3  7  7  3  
ought2b: 0  0  
outcome: 0  0  
================================
test case 240000 of 1000000
initial: 6  2  3  8  
ought2b: 6  6  2  2  8  8  
outcome: 6  6  2  2  8  8  
================================
test case 280000 of 1000000
initial: 8  6  7  9  7  1  1  9  9  
ought2b: 8  8  6  6  
outcome: 8  8  6  6  
================================
test case 320000 of 1000000
initial: 7  5  
ought2b: 
outcome: 
================================
test case 360000 of 1000000
initial: 2  9  6  9  3  7  7  
ought2b: 2  2  6  6  
outcome: 2  2  6  6  
================================
test case 400000 of 1000000
initial: 8  
ought2b: 8  8  
outcome: 8  8  
================================
test case 440000 of 1000000
initial: 6  1  1  1  9  9  7  6  8  
ought2b: 6  6  6  6  8  8  
outcome: 6  6  6  6  8  8  
================================
test case 480000 of 1000000
initial: 8  3  4  
ought2b: 8  8  4  4  
outcome: 8  8  4  4  
================================
test case 520000 of 1000000
initial: 3  6  2  1  6  4  2  
ought2b: 6  6  2  2  6  6  4  4  2  2  
outcome: 6  6  2  2  6  6  4  4  2  2  
================================
test case 560000 of 1000000
initial: 3  3  8  8  4  
ought2b: 8  8  8  8  4  4  
outcome: 8  8  8  8  4  4  
================================
test case 600000 of 1000000
initial: 7  8  6  6  6  0  7  8  5  
ought2b: 8  8  6  6  6  6  6  6  0  0  8  8  
outcome: 8  8  6  6  6  6  6  6  0  0  8  8  
================================
test case 640000 of 1000000
initial: 6  7  0  
ought2b: 6  6  0  0  
outcome: 6  6  0  0  
================================
test case 680000 of 1000000
initial: 5  8  0  3  7  
ought2b: 8  8  0  0  
outcome: 8  8  0  0  
================================
test case 720000 of 1000000
initial: 4  7  9  5  9  3  4  1  4  4  
ought2b: 4  4  4  4  4  4  4  4  
outcome: 4  4  4  4  4  4  4  4  





144 bool DelFirstTargetNode (Node* & headPtr, int target)
145 {
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
194
195
196
197
Node *precursor = 0,
*cursor = headPtr;
while (cursor != 0 && cursor->data != target)
198
199 }
200
precursor = cursor;
cursor = cursor->link;
if (cursor ==
cout << target << "not found." << endl;
return false;
if (cursor == headPtr) //OR precursor == 0
headPtr = headPtr->link;
else
= 0)
precursor->link = cursor->link;
delete cursor;
return true;
}
bool DelNodeBeforelstMatch (Node* & headPtr, int target)
{
if (headPtr == 0 || headPtr->link == 0 || headPtr->data == target) return false;
Node *cur = headPtr->link, *pre = headPtr, *prepre = 0;
while (cur != 0 && cur->data != target)
{
prepre= pre;
pre = cur;
cur = cur->link;
if (cur == 0) return false;
if (cur == headPtr->link)
headPtr = cur;
delete pre;
}
else
185
186
187
188
189
}
190
191 void ShowA11 (ostream& outs, Node* headptr)
192
{
193
prepre->link = cur;
delete pre;
return true;
while (headPtr != 0)
outs << headPtr->data << "
headPtr = headPtr->link;
outs << endl;
Transcribed Image Text:144 bool DelFirstTargetNode (Node* & headPtr, int target) 145 { 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 194 195 196 197 Node *precursor = 0, *cursor = headPtr; while (cursor != 0 && cursor->data != target) 198 199 } 200 precursor = cursor; cursor = cursor->link; if (cursor == cout << target << "not found." << endl; return false; if (cursor == headPtr) //OR precursor == 0 headPtr = headPtr->link; else = 0) precursor->link = cursor->link; delete cursor; return true; } bool DelNodeBeforelstMatch (Node* & headPtr, int target) { if (headPtr == 0 || headPtr->link == 0 || headPtr->data == target) return false; Node *cur = headPtr->link, *pre = headPtr, *prepre = 0; while (cur != 0 && cur->data != target) { prepre= pre; pre = cur; cur = cur->link; if (cur == 0) return false; if (cur == headPtr->link) headPtr = cur; delete pre; } else 185 186 187 188 189 } 190 191 void ShowA11 (ostream& outs, Node* headptr) 192 { 193 prepre->link = cur; delete pre; return true; while (headPtr != 0) outs << headPtr->data << " headPtr = headPtr->link; outs << endl;
1819282122324252527282981234567898423456F8495812345%望8901印3456句品的L123
bool DelOddCopEven (Node* headptr)
{
int FindList Length (Node* headptr)
int length = 0;
while (headPtr != 0)
{
}
{
}
bool Is Sorted Up (Node* headPtr)
{
++length;
headPtr = headPtr->link;
return length;
if
(headPtr == 0 || headPtr->link == 0) // empty or 1-node
return true;
(headPtr->link != 0) // not at Last node
while
if (headPtr->link->data < headPtr->data)
return false;
headPtr = headPtr->link;
void InsertAsHead (Node* & headPtr, int value)
return true;
Node *newNodePtr = new Node;
newNodePtr->data = value;
newNodePtr->link= headPtr;
headPtr = newNodePtr;
void InsertAsTail (Node* & headPtr, int value)
Node *newNodePtr = new Node;
newNodePtr->data = value;
newNodePtr->link
= 0;
if (headPtr == 0)
headPtr newNodePtr;
else
Node *cursor = headPtr;
while (cursor->link != 0) // not at last node
cursor = cursor->link;
cursor->link = newNodePtr;
Transcribed Image Text:1819282122324252527282981234567898423456F8495812345%望8901印3456句品的L123 bool DelOddCopEven (Node* headptr) { int FindList Length (Node* headptr) int length = 0; while (headPtr != 0) { } { } bool Is Sorted Up (Node* headPtr) { ++length; headPtr = headPtr->link; return length; if (headPtr == 0 || headPtr->link == 0) // empty or 1-node return true; (headPtr->link != 0) // not at Last node while if (headPtr->link->data < headPtr->data) return false; headPtr = headPtr->link; void InsertAsHead (Node* & headPtr, int value) return true; Node *newNodePtr = new Node; newNodePtr->data = value; newNodePtr->link= headPtr; headPtr = newNodePtr; void InsertAsTail (Node* & headPtr, int value) Node *newNodePtr = new Node; newNodePtr->data = value; newNodePtr->link = 0; if (headPtr == 0) headPtr newNodePtr; else Node *cursor = headPtr; while (cursor->link != 0) // not at last node cursor = cursor->link; cursor->link = newNodePtr;
Expert Solution
steps

Step by step

Solved in 3 steps

Blurred answer
Knowledge Booster
Array
Learn more about
Need a deep-dive on the concept behind this application? Look no further. Learn more about this topic, computer-science and related others by exploring similar questions and additional content below.
Similar questions
  • SEE MORE QUESTIONS
Recommended textbooks for you
Database System Concepts
Database System Concepts
Computer Science
ISBN:
9780078022159
Author:
Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan
Publisher:
McGraw-Hill Education
Starting Out with Python (4th Edition)
Starting Out with Python (4th Edition)
Computer Science
ISBN:
9780134444321
Author:
Tony Gaddis
Publisher:
PEARSON
Digital Fundamentals (11th Edition)
Digital Fundamentals (11th Edition)
Computer Science
ISBN:
9780132737968
Author:
Thomas L. Floyd
Publisher:
PEARSON
C How to Program (8th Edition)
C How to Program (8th Edition)
Computer Science
ISBN:
9780133976892
Author:
Paul J. Deitel, Harvey Deitel
Publisher:
PEARSON
Database Systems: Design, Implementation, & Manag…
Database Systems: Design, Implementation, & Manag…
Computer Science
ISBN:
9781337627900
Author:
Carlos Coronel, Steven Morris
Publisher:
Cengage Learning
Programmable Logic Controllers
Programmable Logic Controllers
Computer Science
ISBN:
9780073373843
Author:
Frank D. Petruzella
Publisher:
McGraw-Hill Education