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.

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;
};

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 29 1 27
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
outcome: 6 6
0
0
6
test case 5 of 1000000
co co
initial: 1
ought2b: 8
outcome: 8 8 2
8 7
=======
8 2
6 2 2
62 2
=====
test case 40000 of 1000000
initial: 5 5 1
ought2b:
outcome:
9
20 2
2 0 0 22
0 0 2 2
2
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 88
644
=====
test case 160000 of 1000000
initial: 0 4
ought2b: 0 0
outcome: 0 0
4 6 6
4 6
6
====
test case 200000
of 1000000
initial: 1 7 0 3 7 7 3
ought2b: 0
outcome: 0 0
==
=====

_1234567898123456789281223242525728298123456劲89 ¥42²4 45 46 7 8 9 58 123456859 68
10
20
30
40
41
43
47
48
49
50
57
60
#include "nodes_LLOLL.h"
#include "cnPtrQueue.h"
#include <iostream>
using namespace std;
namespace CS3358_SP2023_A5P2
{
// do breadth-first (level) traversal and print data
void ShowA11_BF (PNode* pListHead, ostream& outs)
// to be implemented (part of assignment)
{
}
void
Destroy_clist (CNode*& cListHead)
int count = 0;
CNode* cNodePtr = cListHead;
while (cListHead != 0)
{
{
}
cout << "Dynamic memory for " << count << " CNodes freed"
<< endl;
void Destroy_pList (PNode* & pListHead)
cListHead = cListHead->link;
delete cNodePtr;
cNodePtr = cListHead;
++count;
int count = 0;
PNode* pNodePtr
pListHead;
while (plistHead != 0)
{
}
plistHead
pListHead->link;
Destroy_clist (pNodePtr->data);
}
delete pNodePtr;
pNodePtr = plistHead;
++count;
cout << "Dynamic memory for " << count << " PNodes freed"
<< endl;
=
// do depth-first traversal and print data
void ShowA11_DF (PNode* plistHead, ostream& outs)
=
while (plistHead != 0)
{
{
CNode* cListHead pListHead->data;
while (clistHead != 0)
}
plistHead
outs <<clistHead->data <<
cListHead = clistHead->link;
=
pListHead->link;

Expert Solution

Trending now

This is a popular solution!

Step by step

Solved in 3 steps

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.

Similar questions