Thread: Linked list Segmentation

In addition to what others have said, there are a few other things that should be corrected.

Code:

/* Inserting Last */
Node *insertNode(Node*head,int value){
  Node*newNode=(Node*)malloc(sizeof(Node));

You should check malloc() for NULL.

Code:

/* Inserting in the First */
Node* insertFirst(Node*head,int value){
  Node*newNode=(Node*)malloc(sizeof(Node));

Again, check malloc() for NULL.

In the function

Code:

Node*insertSorted(Node*head,int value)

I would venture to say that you want to return head.

On a side note, I would have just made a seperate function to make the nodes.

Maybe something like

Code:

n_type *l_make(size_t count) 
{ 
    n_type *node, *list; 

    list = count ? malloc(sizeof *list) : NULL; 
    if (list != NULL) { 
        node = list; 
        while (--count != 0) { 
            node -> NEXT = malloc(sizeof *node -> NEXT); 
            if (node -> NEXT == NULL) { 
                l_free(list); 
                return NULL; 
            } else { 
                node = node -> NEXT; 
            } 
        } 
        node -> NEXT = NULL; 
    } 
    return list; 



}

Then when I sort

Code:

n_type *n_sort(n_type *list, size_t count) 
{ 
    size_t half, other_half; 
    n_type *head, *tail, *sorted, **node; 

    if (count > 1) { 
        head = list; 
        other_half = half = count / 2; 
        while (--other_half != 0) { 
            head = head -> NEXT; 
        } 
        tail = head -> NEXT; 
        head -> NEXT = NULL; 
        tail = n_sort(tail, count - half); 
        head = n_sort(list, half);   
        node = GT(head, tail) ? &tail : &head; 
        sorted = list = *node; 
        *node = sorted -> NEXT; 
        while (*node != NULL) { 
            node = GT(head, tail) ? &tail : &head; 
            sorted = sorted -> NEXT = *node; 
            *node = sorted -> NEXT; 
        } 
        sorted -> NEXT = head != NULL ? head : tail; 
    } 
    return list; 



}

Of course this is just my biased opinion on the whole thing.

thanks guys for the help. I made the changes you recommended to my code. I don't get the segmentation fault anymore but my "insertSorted" and "insertnode" functions do not give the correct output. Could someone please take a look and tell me what I am doing wrong.
My Code:

Code:

#include <stdio.h>
#include<stdlib.h>

typedef struct nodeTag{
 int value;
 struct nodeTag*link;
}Node;

/* Inserting Last */
Node *insertNode(Node*head,int value){
  Node*newNode=(Node*)malloc(sizeof(Node));
  newNode->value=value;
  newNode->link=NULL;
  if(!head){ head=newNode;}

  else{
    Node*temp=head;
    while(temp->link){
      temp=temp->link;
      temp->link=newNode;
    } }



  return newNode;
}

/* Printing the list Contents */
void printList(Node*head){
  Node*temp=head;
  while(temp){
    printf("%d  " ,  temp->value);
temp=temp->link;
  }

}

/* Inserting in the First */
Node* insertFirst(Node*head,int value){
  Node*newNode=(Node*)malloc(sizeof(Node));
  newNode->value=value;
  newNode->link=head;
  head=newNode;
  return head;

}

Node*insertSorted(Node*head,int value){
  Node* newNode=(Node*)malloc(sizeof(Node));
  if(head&&(head->value>value)){
    head=insertFirst(head,value);
  }
  else{
    newNode->value=value;
    newNode->link=NULL;
  }
  if(!head){
    head=newNode;
  }

  else{
    Node*temp=head;
    while((temp->link)&&(temp->link->value<value))
      temp=temp->link;
    newNode->link=temp->link;
    temp->link=newNode;

  }
return newNode;
}


int main()
{
  Node*list=NULL;

 //Inserting Last
   list=insertNode(list,10);
   list=insertNode(list,15);
   list=insertNode(list,5);
   printList(list);


 /*Inserting First */
  list=insertFirst(list,12);
  list=insertFirst(list,13);
  list=insertFirst(list,14);
  printList(list);

  list=insertSorted(list,77);
  list=insertSorted(list,200);
  list=insertSorted(list,55);
  printList(list);

}

Hmm.... really?

Code:

Node *insertNode(Node*head,int value){
  Node*newNode=(Node*)malloc(sizeof(Node));

You are still casting malloc() and you still aren't checking malloc() for NULL;

Code:

void printList(Node*head){
  Node*temp=head;
  while(temp){
    printf("%d  " ,  temp->value);
temp=temp->link;
  }

}

You forgot to insert a newline. This leads to undefined behavior. Including but not limited to printf() not printing. I'm pretty sure
while(temp) should be while(temp !=NULL). Zero and NULL are not the same thing.

Skipping down to main()

Code:

int main()

It should be
int main(void)

Code:

{
  Node*list=NULL;

This doesn't seem right. Okay. I need to cut this short. My mom need her computer again.

Yeah, you also forgot to return zero in main.

I think the problem with having list set to NULL is that when it encounters the following lines in your code:

Code:

Node *insertNode(Node*head,int value){
  Node*newNode=(Node*)malloc(sizeof(Node));
  newNode->value=value;
  newNode->link=NULL;
  if(!head){ head=newNode;}

It will always fail. In this case both head and list point to the same thing. NULL. It would suggest the loop will always fail since you have

if(!head)

However, I don't have immediate access c compiler to verify this. With that, Now I'm off.

The two functions that are incorrect are returning newNode. But newNode is not the head of the list in every case, so obviously it wont work.

Hint: You're allowed to have more than one return statement within a function.

thanks a bunch I got it to work.

Here is the working one:

Code:

#include <stdio.h>
#include<stdlib.h>

typedef struct nodeTag{
 int value;
 struct nodeTag*link;
}Node;

/* Inserting Last */
Node *insertNode(Node*head,int value){
  Node*newNode=(Node*)malloc(sizeof(Node));
  newNode->value=value;
  newNode->link=NULL;
  if(head==NULL){
    head=newNode;
}
  else{

  Node*temp=head;


    while(temp->link!=NULL){
        temp=temp->link;}
        temp->link=newNode;


   }
 return head;
}




/* Printing the list Contents */
void printList(Node*head){
  Node*temp=head;
  while(temp){
    printf("%d  " ,  temp->value);
temp=temp->link;
  }

}

/* Inserting in the First */
Node* insertFirst(Node*head,int value){
  Node*newNode=(Node*)malloc(sizeof(Node));
  newNode->value=value;
  newNode->link=head;
  head=newNode;
  return head;

}

Node*insertSorted(Node*head,int value){
  Node* newNode=(Node*)malloc(sizeof(Node));
  if(head&&(head->value>value)){
    head=insertFirst(head,value);
  }
  else{
    newNode->value=value;
    newNode->link=NULL;
  }
  if(!head){
    head=newNode;
  }

  else{
    Node*temp=head;
    while((temp->link)&&(temp->link->value<value))
      temp=temp->link;
    newNode->link=temp->link;
    temp->link=newNode;

  }
return head;
}


int main()
{
  Node*list=NULL;

 //Inserting Last
   list=insertNode(list,10);
   list=insertNode(list,15);
   list=insertNode(list,5);

/*Inserting First */
  list=insertFirst(list,12);
  list=insertFirst(list,13);
  list=insertFirst(list,14);

  list=insertSorted(list,77);
  list=insertSorted(list,200);
  list=insertSorted(list,55);
  printList(list);


}