Find Maximum sum of k consecutive nodes in linked list

// C Program 
// Find Maximum sum of k consecutive nodes in linked list
#include <stdio.h>

#include <stdlib.h> //for malloc function

// Linked List LinkNode
struct LinkNode
{
	int data;
	struct LinkNode *next;
};
// Singly linked list 
struct SingleLL
{
	struct LinkNode *head;
	struct LinkNode *tail;
};
// Returns the new linked list
struct SingleLL *newLinkedList()
{
	// Create memory of head and tail Nodes
	struct SingleLL *sll = (struct SingleLL *) malloc(sizeof(struct SingleLL));
	if (sll == NULL)
	{
		printf("Memory overflow\n");
	}
	else
	{
		sll->head = NULL;
	}
	return sll;
}
// Returns a new Node of linked list
struct LinkNode *createLinkNode(int data)
{
	// Create dynamic node
	struct LinkNode *node = (struct LinkNode *) malloc(sizeof(struct LinkNode));
	if (node == NULL)
	{
		printf("Memory overflow\n");
	}
	else
	{
		// Set initial node value
		node->data = data;
		node->next = NULL;
	}
	return node;
}
// Add new Node at end of linked list 
void addNode(struct SingleLL *sll, int data)
{
	struct LinkNode *node = createLinkNode(data);
	if (sll->head == NULL)
	{
		sll->head = node;
	}
	else
	{
		struct LinkNode *temp = sll->head;
		// Find last node
		while (temp->next != NULL)
		{
			temp = temp->next;
		}
		// Append the node at last position
		temp->next = node;
	}
}
// Display linked list element
void display(struct SingleLL *sll)
{
	if (sll->head == NULL)
	{
		printf("\n Empty linked list\n");
		return;
	}
	struct LinkNode *temp = sll->head;
	// iterating linked list elements
	while (temp != NULL)
	{
		if (temp != sll->head)
		{
			printf(" →");
		}
		printf(" %d", temp->data);
		// Visit to next node
		temp = temp->next;
	}
	printf(" → NULL\n");
}
// Find the max sum of consecutive K nodes
void consecutiveKSum(struct SingleLL *sll, int k)
{
	if (sll->head == NULL || k < 1)
	{
		return;
	}
	struct LinkNode *auxiliary = sll->head;
	struct LinkNode *start = sll->head;
	int result = 0;
	int sum = 0;
	int counter = 1;
	// Execute linked list node
	while (auxiliary != NULL)
	{
		sum = sum + auxiliary->data;
		if (counter >= k)
		{
			if (counter == k)
			{
				// Get first pair of k nodes
				result = sum;
			}
			else
			{
				sum = sum - start->data;
				if (sum > result)
				{
					result = sum;
				}
				// Visit to next node
				start = start->next;
			}
		}
		// Visit to next node
		auxiliary = auxiliary->next;
		counter++;
	}
	if (counter <= k)
	{
		printf("\n %d Consecutive nodes are not exists", k);
	}
	else
	{
		// Display calculated result
		printf(" Consecutive %d-nodes max sum is : %d\n", k, result);
	}
}
int main()
{
	// Create a empty linked list
	struct SingleLL *sll = newLinkedList();
	//  Constructed linked list
	//  7 → -2 → 3 → 4 → 8 → 6 → -2 → 12 → 4 → NULL
	addNode(sll, 7);
	addNode(sll, 2);
	addNode(sll, 3);
	addNode(sll, 4);
	addNode(sll, 8);
	addNode(sll, 6);
	addNode(sll, -2);
	addNode(sll, 12);
	addNode(sll, 4);
	display(sll);
	int k = 4;
	consecutiveKSum(sll, k);
	return 0;
}

Output

 7 → 2 → 3 → 4 → 8 → 6 → -2 → 12 → 4 → NULL
 Consecutive 4-nodes max sum is : 24