MHB Linked list negative values counting.

AI Thread Summary
The discussion revolves around an issue with counting negative numbers in a linked list implemented in C++. The user is attempting to count the number of negative integers generated randomly and stored in the linked list but is encountering incorrect output. The primary problem identified is that the code incorrectly assigns the value of `currObj->GetDataVal()` to `negativeCntr`, which does not perform a count but rather stores a single data value. To correctly count the negatives, the user needs to check if the current node's value is negative and increment `negativeCntr` accordingly. Additionally, there are suggestions to clarify how the output relates to the list contents and to ensure that the `GetDataVal` function returns the expected value. Overall, the focus is on correcting the counting logic and understanding the linked list's structure.
Teh
Messages
47
Reaction score
0
I am having trouble with this program with negativeCntr . Any one explain what i am doing wrong and guide me please.

Code:
[CODE]#include <iostream>
#include <cstdlib>
using namespace std;

class IntNode {
public:
   IntNode(int dataInit = 0, IntNode* nextLoc = 0);
   void InsertAfter(IntNode* nodePtr);
   IntNode* GetNext();
   int GetDataVal();
private:
   int dataVal;
   IntNode* nextNodePtr;
};

// Constructor
IntNode::IntNode(int dataInit, IntNode* nextLoc) {
   this->dataVal = dataInit;
   this->nextNodePtr = nextLoc;
   return;
}

/* Insert node after this node.
 * Before: this -- next
 * After:  this -- node -- next
 */
void IntNode::InsertAfter(IntNode* nodeLoc) {
   IntNode* tmpNext = 0;

   tmpNext = this->nextNodePtr;    // Remember next
   this->nextNodePtr = nodeLoc;    // this -- node -- ?
   nodeLoc->nextNodePtr = tmpNext; // this -- node -- next
   return;
}

// Grab location pointed by nextNodePtr
IntNode* IntNode::GetNext() {
   return this->nextNodePtr;
}

int IntNode::GetDataVal() {
   return this->dataVal;
}

int main() {
   IntNode* headObj = 0; // Create intNode objects
   IntNode* currObj = 0;
   IntNode* lastObj = 0;
   int i = 0;            // Loop index
   int negativeCntr = 0;

   headObj = new IntNode(-1);        // Front of nodes list
   lastObj = headObj;

   for (i = 0; i < 10; ++i) {        // Append 10 rand nums
      currObj = new IntNode((rand() % 21) - 10);
      lastObj->InsertAfter(currObj); // Append curr
      lastObj = currObj;             // Curr is the new last item
   }

   currObj = headObj;                // Print the list
   while (currObj != 0) {
      cout << currObj->GetDataVal() << ", ";
      currObj = currObj->GetNext();
   }
   cout << endl;

   currObj = headObj;                // Count number of negative numbers
   while (currObj != 0) {

      /* Your solution goes here  */
   
      negativeCntr = currObj->GetDataVal();
      
      currObj = currObj->GetNext();
   }
   cout << "Number of negatives: " << negativeCntr << endl;

   return 0;
Testing with 6 negatives
Expected output: Number of negatives: 6
Your output: Number of negatives: -8
 
Technology news on Phys.org
If you're supposed to be counting the number of negatives, where's your code that is doing the counting?
 
squidsk said:
If you're supposed to be counting the number of negatives, where's your code that is doing the counting?

This is my code for counting the number of negatives but I am not sure if it it right.

Code:
negativeCntr = currObj->GetDataVal();
 
If that code is supposed to count (i.e. do addition) I think you're missing something critical on the line. Also if you're supposed to count only the negative numbers you need to figure out whether the number at that spot in the linked list is negative. Two other questions for you to ponder. First how does your output relate to the contents of the list (make changes to the list to get a better sense of this). Two what does the function GetDataVal return and what are you currently expecting it to return.
 
Thread 'Is this public key encryption?'
I've tried to intuit public key encryption but never quite managed. But this seems to wrap it up in a bow. This seems to be a very elegant way of transmitting a message publicly that only the sender and receiver can decipher. Is this how PKE works? No, it cant be. In the above case, the requester knows the target's "secret" key - because they have his ID, and therefore knows his birthdate.

Similar threads

Replies
11
Views
12K
Replies
2
Views
6K
Replies
2
Views
2K
Replies
5
Views
2K
Replies
1
Views
1K
Replies
23
Views
2K
Replies
1
Views
2K
Back
Top