I need help fixing my function for void DelOddCopEven(Node*& headPtr). When I run my code it pass the first test but it crash after that. I am to replicate the test output but I don't know where the error in my function. Here is my results is my results. passed test on empty list test case 1 of 1000000 given list: 6 7 5 3 signal: segmentation fault (core dumped) And here is the test output ================================ 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 ================================ test case 760000 of 1000000 initial: 6 8 2 8 4 9 9 8 6 ought2b: 6 6 8 8 2 2 8 8 4 4 8 8 6 6 outcome: 6 6 8 8 2 2 8 8 4 4 8 8 6 6 ================================ test case 800000 of 1000000 initial: 6 2 4 8 6 ought2b: 6 6 2 2 4 4 8 8 6 6 outcome: 6 6 2 2 4 4 8 8 6 6 ================================ test case 840000 of 1000000 initial: 0 1 0 1 0 6 1 1 2 1 ought2b: 0 0 0 0 0 0 6 6 2 2 outcome: 0 0 0 0 0 0 6 6 2 2 ================================ test case 880000 of 1000000 initial: 1 2 4 1 7 2 ought2b: 2 2 4 4 2 2 outcome: 2 2 4 4 2 2 ================================ test case 920000 of 1000000 initial: 3 2 8 0 4 1 5 2 6 4 ought2b: 2 2 8 8 0 0 4 4 2 2 6 6 4 4 outcome: 2 2 8 8 0 0 4 4 2 2 6 6 4 4 ================================ test case 960000 of 1000000 initial: 1 6 0 3 6 3 ought2b: 6 6 0 0 6 6 outcome: 6 6 0 0 6 6 ================================ test case 1000000 of 1000000 initial: 1 2 ought2b: 2 2 outcome: 2 2 ================================ test program terminated normally

I need help fixing my function for void DelOddCopEven(Node*& headPtr). When I run my code it pass the first test but it crash after that. I am to replicate the test output but I don't know where the error in my function. Here is my results is my results. passed test on empty list test case 1 of 1000000 given list: 6 7 5 3 signal: segmentation fault (core dumped) And here is the test output ================================ 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 ================================ test case 760000 of 1000000 initial: 6 8 2 8 4 9 9 8 6 ought2b: 6 6 8 8 2 2 8 8 4 4 8 8 6 6 outcome: 6 6 8 8 2 2 8 8 4 4 8 8 6 6 ================================ test case 800000 of 1000000 initial: 6 2 4 8 6 ought2b: 6 6 2 2 4 4 8 8 6 6 outcome: 6 6 2 2 4 4 8 8 6 6 ================================ test case 840000 of 1000000 initial: 0 1 0 1 0 6 1 1 2 1 ought2b: 0 0 0 0 0 0 6 6 2 2 outcome: 0 0 0 0 0 0 6 6 2 2 ================================ test case 880000 of 1000000 initial: 1 2 4 1 7 2 ought2b: 2 2 4 4 2 2 outcome: 2 2 4 4 2 2 ================================ test case 920000 of 1000000 initial: 3 2 8 0 4 1 5 2 6 4 ought2b: 2 2 8 8 0 0 4 4 2 2 6 6 4 4 outcome: 2 2 8 8 0 0 4 4 2 2 6 6 4 4 ================================ test case 960000 of 1000000 initial: 1 6 0 3 6 3 ought2b: 6 6 0 0 6 6 outcome: 6 6 0 0 6 6 ================================ test case 1000000 of 1000000 initial: 1 2 ought2b: 2 2 outcome: 2 2 ================================ test program terminated normally

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

Question

passed test on empty list
test case 1 of 1000000
given list: 6 7 5 3
signal: segmentation fault (core dumped)

And here is the test output

================================
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
================================
test case 760000 of 1000000
initial: 6 8 2 8 4 9 9 8 6
ought2b: 6 6 8 8 2 2 8 8 4 4 8 8 6 6
outcome: 6 6 8 8 2 2 8 8 4 4 8 8 6 6
================================
test case 800000 of 1000000
initial: 6 2 4 8 6
ought2b: 6 6 2 2 4 4 8 8 6 6
outcome: 6 6 2 2 4 4 8 8 6 6
================================
test case 840000 of 1000000
initial: 0 1 0 1 0 6 1 1 2 1
ought2b: 0 0 0 0 0 0 6 6 2 2
outcome: 0 0 0 0 0 0 6 6 2 2
================================
test case 880000 of 1000000
initial: 1 2 4 1 7 2
ought2b: 2 2 4 4 2 2
outcome: 2 2 4 4 2 2
================================
test case 920000 of 1000000
initial: 3 2 8 0 4 1 5 2 6 4
ought2b: 2 2 8 8 0 0 4 4 2 2 6 6 4 4
outcome: 2 2 8 8 0 0 4 4 2 2 6 6 4 4
================================
test case 960000 of 1000000
initial: 1 6 0 3 6 3
ought2b: 6 6 0 0 6 6
outcome: 6 6 0 0 6 6
================================
test case 1000000 of 1000000
initial: 1 2
ought2b: 2 2
outcome: 2 2
================================
test program terminated normally
================================

1 #include <iostream>
#include <cstdlib>
#include "llcpInt.h"
4 using namespace std;
5 void DeloddCopEven (Node*& headptr) {
Node* orig = headPtr;
Node* copy = 0;
Node* previous = NULL;
W23
1.0
6
7
8
9
10-
11
12
13
14
15
Է
929
16
17
18
19
ANZEN4272 mm
20
21
23
25
26
28
V
29
30 ✓
31
32
33
34
35
36
37 }
while (orig != 0) {
if (orig->data % 2
== 0) {
Node* copyNode new Node;
copyNode->data = orig->data;
}
else {
}
if (copy == NULL) {
copy copyNode;
previous = copyNode;
}
else {
orig = temp;
previous->link = copyNode;
previous = copyNode;
Node* temp = orig->link;
orig->link = copyNode;
copyNode->link = temp;
Node* temp
orig = temp;
==
}
delete orig;
=
}
headPtr = copy;
=
orig->link;

64 void InsertAsHead (Node* & headPtr, int value)
65 {
66
67
68
69
70
71
81
82
83
84
72 void InsertAsTail(Node*& headPtr, int value)
73
74
75
76
77
78
79
80 ✓
85
86
87
88
V
89
90 V
91
92
93
94
95
96
97
98
99
}
V
{
Node *newNodePtr = new Node;
newNodePtr->data = value;
newNodePtr->link = headPtr;
headPtr = newNodePtr;
}
Node *newNodePtr = new Node;
newNodePtr->data = value;
newNodePtr->link = 0;
if (headPtr == 0)
else
{
}
headPtr = newNodePtr;
Node *cursor = headPtr;
while (cursor->link != 0) // not at last node
cursor = cursor->link;
cursor->link = newNodePtr;
void InsertSorted Up (Node* & headPtr, int value)
{
}
Node *precursor =
*cursor = headPtr;
while (cursor != 0 && cursor->data < value)
{
precursor = cursor;
cursor = cursor->link;

Expert Solution

Trending now

This is a popular solution!

Step by step

Solved in 2 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.