You are to complete a partial program incorporating a function DelOddCopEven that is to delete all odd-valued nodes and copy each even-valued node of a given list: ● The original order in which the remaining (even-valued) nodes must be preserved, with each original node and its duplicate appearing together. 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 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 bool DelOddCopEven(Node* headPtr) { }

You are to complete a partial program incorporating a function DelOddCopEven that is to delete all odd-valued nodes and copy each even-valued node of a given list: ● The original order in which the remaining (even-valued) nodes must be preserved, with each original node and its duplicate appearing together. 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 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 bool DelOddCopEven(Node headPtr) { }

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

See similar textbooks

Related questions

Concept explainers

Question

You are to complete a partial program incorporating a function DelOddCopEven that is to delete all odd-valued nodes and copy each even-valued node of a given list:

●

The original order in which the remaining (even-valued) nodes must be preserved, with each original node and its duplicate appearing together.

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

bool DelOddCopEven(Node* headPtr) {

}

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 27
ought2b: 6 6 2 2 2 2
outcome: 6 6 2 2 22
=====
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
outcome: 6 6 0 0
6
========
test case 5 of 1000000
initial: 1 8
7
9
2
ought2b: 8 8 2 2 0 0
outcome: 8 8 2 2
0
0
=======
test case 40000 of 1000000
initial: 5 5 1
ought2b:
outcome:
6 2
test case 80000 of 1000000
initial: 2
ought2b: 2 2
outcome: 2 2
=========
6 22
0 2
test case 120000 of 1000000
initial: 4 4 1 8
ought2b: 4 4
4 8
4
outcome: 4 4 4 4
co co
=====
8
=====
~~
8 8
test case 160000 of 1000000
initial: 04 6
ought2b: 0 0 4 4 6 6
outcome: 0 0 4 4 6 6
2
NN
22
2 2
test case 200000 of 1000000
initial: 1 7 0 3 7 7 3
ought2b: 0 0
outcome: 0 0

List before
(empty)
1
2
1
1
|1 2
2 1
2 2
1 1 1
1
1 2
1
2 1
2 1 1
1 22
2 1 2
2 2
1
2 2 2
1 2 3
1 2 3
2 1 3
2 1 4 3
4
2 1 3
1 3 2
14
4
4
5 1 2 2
2 1
5
2
1 2
2
5
2
4
4
9
5
5
5 3 40
3
0 4
2 5 19 5
3 4
09
3 4 09
4
4
List after
(empty)
(empty)
2 2
(empty)
2
2
2
(empty)
2
2
2
2
2
2
2
2 2
2
2
2
2
2
2
2
4
2
2 2 2
2 2 2
22
2 2
2
2 4
2 4
2 4
24
4
4 2
2
2 2
2
2
2 2 2
2 2 2 2
2 22 2
12
2
2
2
2
22 2
4
4
4
4 4 4 4 00
4
4
4 4 0 0
4
4 0
044
0 4 4 4 4

Expert Solution

Trending now

This is a popular solution!

Step by step

Solved in 3 steps with 1 images

SEE SOLUTION Check out a sample Q&A here

Knowledge Booster

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.