C++ Linked List Node met klasse

Het doel hier is met name om een gekoppelde structuur te maken met een aantal knooppunten, tussen de 5 en 2 miljoen. Maak je geen zorgen dat dit aantal groot is of dat waarden voorbij de maximale grootte van een geheel getal kunnen lopen. Als je je gekoppelde structuur correct hebt gemaakt, kan een moderne computer deze code heel snel doornemen. Merk op dat de opmerkingen precies beschrijven hoe deze main zou moeten werken. Dit zijn de hoogtepunten:

Maak drie lussen
De eerste lus creëert de gekoppelde structuur, verbindt de “volgende” velden van elk knooppunt en geeft elk knooppunt een geheel getal tussen 0 en de willekeurig gekozen grootte.
De tweede lus telt alle knooppunten op en telt ze. Het tellen van de knooppunten moet in dit geval alleen worden gebruikt als controle om er zeker van te zijn dat u er geen mist.
De derde lus doorloopt alle knooppunten opnieuw, deze keer worden ze verwijderd.

Node.h

class Node {
public:
    Node();
    Node(const Node& orig);
    virtual ~Node();
    bool hasNext();
    Node* getNext();
    void setNext(Node* newNext);
    int getValue();
    void setValue(int val);
private:
    Node* next;
    int value;
};
#endif

Node.cpp

include "Node.h"
include <iostream>
Node::Node() {
    next = NULL;
}
Node::Node(const Node& orig) {
    next = orig.next;
    value = orig.value;
}
Node::~Node() {
}
bool Node::hasNext(){
    if (next != NULL)
        return true;
    else
        return false;
}
Node* Node::getNext(){
    return next;
}
void Node::setNext(Node* newNext){
    if(newNext == NULL)
        next = NULL;
    else
        next = newNext->next;
}
int Node::getValue(){
    return value;
}
void Node::setValue(int val){
    value = val;
}

main.cpp

include <cstdlib>
include <iostream>
include "Node.h"
include <time.h>
using namespace std;
int main(int argc, char** argv) {
    //This is the node that starts it all
    Node *tail;
    Node* head = new Node();
    //select a random number between 5 and 2,000,000
    srand(time(NULL));
    int size = (rand() % 2000000) + 5;
    int total = 0;
    int counter = 0;
    //print out the size of the list that will be created/destroyed
    cout << "The total size is: " << size << endl;
    head->setValue(0);
    tail = head;
    Node *newNode = new Node;
    for (int i = 1; i < size; i++){  
        Node *newNode = new Node;
        newNode->setValue(i);
        newNode->setNext(NULL);
        tail->setNext(newNode);
        tail = newNode;
    }
    //Create a list that counts from 0 to 2,000,000
    //Link all of the nodes together
    //A for loop is easiest here
    cout << head->getNext()->getValue();
    Node* current = head;
    while (current != NULL){ 
        counter += current->getValue();
        cout << current->getValue();
        current = current->getNext();
        total++;
    }
    //Traverse the list you created and add up all of the values
    //Use a while loop
    //output the number of nodes. In addition, print out the sum
    //of all of the values of the nodes.
    cout << "Tracked " << total << " nodes, with a total count of " << counter << endl;
    //Now loop through your linked structure a third time and
    //delete all of the nodes
    //Again, I require you use a while loop
    cout << "Deleted " << total << " nodes. We're done!" << endl;
    return 0;
}

Het is dan de totale grootte aan het afdrukken…
Ik krijg een Seg-fout:11.
Ik mis ook een aantal delen in het algemeen, ik weet ook niet hoe ik deze moet schrijven.


Antwoord 1, autoriteit 100%

het moet next = newNext;zijn in plaats van next = newNext->next;

void Node::setNext(Node* newNext){
    if(newNext == NULL)
        next = NULL;
    else
        next = newNext;
}

Other episodes