减去链表的2个连续节点时出现分段错误

Question

my aim is to create a function to subtract 2 consecutive numbers and then add that result to the front of those numbers

eg:
input: 2->4->1->6->9->8->7
output: -2->2->4->-5->1->6->1->9->8->7

So this is my logic so far:

struct node
{
    int data;
    node *next;
};
void SubtractConsecutiveNodes()
{
    if(head==NULL || head->next==NULL)
    {
        return;
    }

    node *first =head,*prev;
    node *newNode;
    while(first!=NULL&&first->next!=NULL)
    {
        newNode->data=first->data-first->next->data;
        newNode->next = first;

        if(head== first)
            head = newNode;
        else
            prev->next=newNode;

        prev = first->next;
        first=first->next->next;
    }
}

but the problem is after doing first Iteration loop seems to go into a segmentation fault and then crash.

Link to my whole code: Assignment-3

Answer 1

In

void SubtractConsecutiveNodes()
{
    if(head==NULL || head->next==NULL)
    {
        return;
    }

    node *first =head,*prev;
    node *newNode;
    while(first!=NULL&&first->next!=NULL)
    {
        newNode->data=first->data-first->next->data;
        newNode->next = first;

        if(head== first)
            head = newNode;
        else
            prev->next=newNode;

        prev = first->next;
        first=first->next->next;
    }
}

newnode is not pointed at anything before it is dereferenced during

newNode->data=first->data-first->next->data;

A crash is one of the more polite things that can result from using an uninitialzed pointer, so a

node *newNode = new node;

is in order.

Addendum

I hate prev variables. I'm not sure why. Maybe I was murdered in a previous life or something. Anyway, There's neat trick with a pointer to a pointer you can use to get rid of prev s and, at the same time, a lot of head -specific logic.

A lot of the time multiple indirection (pointers to pointers) is frowned on, but pointers are like fire: A powerful servant, but a terrible master. Master the pointer and by Crom, you can write some cool software!

void SubtractConsecutiveNodes()
{
    // if first is a pointer to a pointer to a node, we can point it at a `next`
    // and eliminate the need for prev. This has the added bonus of turning head
    // into just another next pointer, eliminating all of the head-specific logic.
    // if(head==NULL || head->next==NULL) is identical to the while exit condition 
     // once head is hidden behind first. Chuck it. You don't need it. 
    node **first = &head;
    while ((*first) != NULL && (*first)->next != NULL) 
        // extra level of indirection, so extra dereferencing required.
    {
        node *newNode = new node;
        newNode->data = (*first)->data - (*first)->next->data;
        newNode->next = *first;
        (*first) = newNode; // places newnode directly into prev->next or head, 
                            // whichever happens to be there.

        first = &(*first)->next->next->next; 
        //since we added another node in we need an extra ->next
    }
}