ALGORITHM

• INSERTION AT THE HEAD NODE (starting)
  1. if ptr = NULL. Print “OVERFLOW” go to 8th step and exit
  2. if ptr not equal to null then follow the steps below
  3. SET NEW_NODE = PTR
  4. SET PTR = HEAD
  5. SET PTR → NEXT = HEAD → NEXT
  6. EXIT
• INSERTION AT THE END
  1. if ptr = null. write “OVERFLOW”, go to 6th step and exit
  2. if not then follow the next steps
  3. WHEN PTR → NEXT = NULL .i.e. The pointer have reached the last element of the linked list
  4. SET PTR → NEXT = NEW_NODE
  5. SET NEW_NODE → NEXT = NULL
  6. EXIT
• INSERTION IN BETWEEN
  1. if ptr = null. write “OVERFLOW”, go to 7th step and exit
  2. if not then follow the next steps
  3. Take input for the position or the pre_node address or value.
  4. Traverse through the loop till you reach the pre_node and then perform the mentioned steps
  5. SET PTR → NEXT = PRE_NODE → NEXT
  6. SET PRE_NODE → NEXT = PTR
  7. exit

SOURCE CODE

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

struct node {
    int data;
    struct node * next;
};

Functions for the Linked List Insertions

1. Insert at First

struct node * insertAtFirst(struct node *head, int data){
    struct node * ptr = (struct node *)malloc(sizeof(struct node));
    ptr -> next = head;
    ptr -> data = data;
    return ptr;
}

1. Insert at end

struct node * insertAtEnd(struct node *head, int data){
    struct node * ptr = (struct node *)malloc(sizeof(struct node));
    ptr -> data = data;
    struct node *p = head;

    while (p -> next != NULL){
        p = p -> next;
    }
    p -> next = ptr;
    ptr -> next = NULL;
    return head;
}

1. Insert at Index

struct node * insertAtIndex(struct node *head, int data, int index){
    struct node * ptr = (struct node *)malloc(sizeof(struct node));
    struct node * p = head;
    int i = 0;
    while (i != index-1){
        p = p -> next;
        i++;
    }
    ptr -> data = data;
    ptr -> next  = p -> next;
    p -> next = ptr;
    return head;

}

1. Insert after

// inserting a node after a certain perticular node.
struct node * insertAfter(struct node * head,struct node *prevNode, int data){
    struct node * ptr = (struct node*) malloc(sizeof(struct node));
    ptr -> data = data;

    ptr -> next = prevNode -> next;
    prevNode -> next = ptr;

    return head;
}

now the main function ()

int main(){
	// node * xyx (xyz is a Pointer variable)
	struct node * head;
	struct node * second;
	struct node * third;
	struct node * fourth;

	//allocate memory for nodes in HEAP

	head = (struct node *) malloc(sizeof(struct node));
	second = (struct node *) malloc(sizeof(struct node));
	third = (struct node *) malloc(sizeof(struct node));
	fourth = (struct node *) malloc(sizeof(struct node));

	//link nodes '->' arrow operator

	head -> data = 1;
	head -> next = second;
	second -> data = 2;
	second -> next = third;
	third -> data = 3;
	third -> next = fourth;
	//this is how to take input for a linked list node
	//printf("Enter the element for 4th node : ");
	//scanf("%d", &fourth -> data);
    fourth -> data = 4;
	fourth -> next = NULL;
    
    printf("Linked list before insertion \\n");
    linkedlistTraversal(head);

// uncomment the function call that you wanna use in this program

    //head = insertAtFirst(head, 10);
    //head = insertAtIndex(head, 20, 2);
    //head = insertAtEnd(head, 30);
    //head = insertAfter(head, third, 40);//node will be inserted after third node.
    printf("Linked list after insertion at the end: \\n");
	linkedlistTraversal(head);
return 0;
}

Compile all the snippets together to make it a fully functional working program.