Linked list negative values counting.

In summary, the conversation is about a student who is having trouble with a program related to negative numbers and is seeking guidance. The conversation includes code for a linked list and a loop to count the number of negative numbers in the list. The expert provides feedback on the code and encourages the student to think about the purpose of the code and how to properly count the negatives.
  • #1
Teh
47
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
  • #2
If you're supposed to be counting the number of negatives, where's your code that is doing the counting?
 
  • #3
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();
 
  • #4
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.
 

FAQ: Linked list negative values counting.

How do you count negative values in a linked list?

In order to count negative values in a linked list, you can iterate through the list and check each element's value. If the value is less than 0, you can increment a counter variable. Once you have iterated through the entire list, the counter variable will contain the total number of negative values in the linked list.

Can a linked list contain negative values?

Yes, a linked list can contain negative values. A linked list is a data structure that can hold any type of data, including negative numbers. It is a linear collection of elements where each element contains a pointer to the next element, allowing for flexible storage of data.

Does the position of a negative value in a linked list affect the counting process?

No, the position of a negative value in a linked list does not affect the counting process. As long as the negative value is present in the linked list, it will be counted when iterating through the list. The position of the value only matters when accessing or manipulating specific elements in the list.

What is the time complexity of counting negative values in a linked list?

The time complexity of counting negative values in a linked list is O(n), where n is the number of elements in the list. This is because the algorithm needs to iterate through the entire list to count all the negative values, resulting in a linear time complexity.

Can negative values be counted in a doubly linked list?

Yes, negative values can be counted in a doubly linked list. A doubly linked list is similar to a regular linked list, but each element contains a pointer to both the next and previous element. The process of counting negative values would be the same, by iterating through the list and checking each element's value.

Similar threads

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