如何在链表 C++ 的开头插入一个数字？

Question

I am trying to insert a number into a linked list that is sorted in increasing order, I have the parts where I insert in the middle and at the end but I can seem to do it when the value is less than the starting value.

void List::InsertInFibonacci()
{
first = new Node(0,NULL);
Node* current = first;
Node* second = new Node (1,NULL);
current->setNext(second);
bool x = true, y = true;
// Algorithm for Fibonacci Sequence
for(int i = 0;i<5;i++)
{
    current = first;
    while(current&&x==true)
    {
        if(current->getNext()->getNext()==NULL)
        {
            x=false;
        }
        else
        {
            current = current->getNext();
        }
    }
    int temp = current->getData() + current->getNext()->getData();
    Node* slider = new Node(temp,NULL);
    current->getNext()->setNext(slider);
    x=true;
}
current=first;
Node* number = new Node(-4,NULL);
// Loop to insert a number inside my sorted list
while(current&&y==true)
{
    // Inserts in the end
    if(current->getData()<number->getData()&&current->getNext()==NULL)
    {
        current->setNext(number);
        y=false;
    }
    //Inserts in the beginning
    if(number->getData()<first->getData())
    {
        number->setNext(current);
        current = number;
        y=false;
    }
    // Inserts in the middle
    else if(current->getData()<number->getData()&&current->getNext()->getData()>number->getData())
    {
        number ->setNext(current->getNext());
        current->setNext(number);
        y=false;
    }
    else
    {
        current = current->getNext();
    }
}
current = first;
// Prints my list
while (current)
{
    cout<<current->getData()<<"   ";
    current = current->getNext();
}
cout<<endl;

}

When I try and run it as it is, I will not get -4 at the start and I will only get my previous list. Note that all of my variables have been previously defined this is just the snippet of the part that isn't working.

Answer 1

You want to have a pointer to the head of the list and then change where it is pointing when you add a new element

Generally, you can achieve this with something similar.

class Node{
   public:
   Node(int val)
   {
       this->val = val;
       this->next = nullptr
   }
   int val;
   Node* next;
}

Then you can use it like this.

Node element1(5);
Node element2(10);

Node* head = &element1
//add a new node in front

head->next = head;
head = &element2;

Answer 2

I assume that you node values of your list are sorted. You need first to set the variable first to number inside the conditional section Insert into begininng so that this variable will point to the node you want to add. You should also remove the line current = number . Moreover, your loop does not work with empty lists. In such case, you have to set the first variable to number too. Finally, please note that the variable second defined in the beginning of your code will not point to the second node anymore.

Answer 3

At the time of writing, it looks like you've solved your particular problem. But I wrote this code and don't want to just delete it. It does demonstrate how simple an insert function can be for a sorted linked list. Note the lack of an over-arching while loop, and how simplistic the one loop is.

My list is doubly linked, which I prefer since it makes mid-list erasing so much easier. I didn't write an erase function because it doesn't pertain to your question. There's actually a lot I didn't write that really should be included (big exclusions include a copy constructor and assignment operator overload; Rule of 3 is in play).

I wrote a print function as a class member to simplify things, but the reality is you should write an iterator class instead. My personal preference would have been to write a fully fleshed linked list, and then composite it into a sorted linked list.

#include <iostream>
#include <random>

class Dlist {
public:
    Dlist() = default;
    ~Dlist();
    void insert(int data);
    void print() const;

private:
    struct Node {
        Node(int key)
            : key_m(key)
        {
        }
        int key_m = 0;
        Node* prev_m = nullptr;
        Node* next_m = nullptr;
    };

    Node* head_m = nullptr;
    Node* tail_m = nullptr;
};

Dlist::~Dlist()
{
    while (head_m) {
        Node* tmp = head_m;
        head_m = head_m->next_m;
        delete tmp;
    }
    head_m = nullptr;
    tail_m = nullptr;
}

void Dlist::insert(int data)
{
    Node* tmp = new Node(data);
    if (!head_m) {
        head_m = tmp;
        tail_m = head_m;
        return;
    }

    if (data < head_m->key_m) { // New node goes before head
        tmp->next_m = head_m;
        head_m->prev_m = tmp;
        head_m = tmp;
    } else if (data > tail_m->key_m) { // New node goes after tail
        tail_m->next_m = tmp;
        tmp->prev_m = tail_m;
        tail_m = tmp;
    } else { // New node goes somewhere in the middle
        Node* insertingBefore = head_m->next_m;
        while (tmp->key_m > insertingBefore->key_m && insertingBefore != tail_m) {
            insertingBefore = insertingBefore->next_m;
        }
        tmp->next_m = insertingBefore;
        tmp->prev_m = insertingBefore->prev_m;
        insertingBefore->prev_m->next_m = tmp;
        insertingBefore->prev_m = tmp;
    }
}

void Dlist::print() const
{
    if (!head_m) {
        return;
    }

    Node* i = head_m;
    while (i) {
        std::cout << i->key_m << ' ';
        i = i->next_m;
    }
}
int main()
{
    Dlist list;
    std::random_device rd;
    std::mt19937 engine(rd());
    std::uniform_int_distribution<int> dist(1, 100);

    for (int i = 0; i < 10; ++i) {
        int tmp = dist(engine);
        std::cout << "Inserting " << tmp << ".\n";
        list.insert(tmp);
    }

    list.print();
    std::cout << '\n';
}

Your class function sounds like it is generating data to insert into the list. That sounds horrible. A list is a list, and nothing more. That data generation should be in a non-class function, which should then call the insert() function of your list. A class should represent one thing well, and a function should do one thing well. These are foundational principles.