How to make this list a circular list? - c

Question

The code is the next, I would like for the last item in the list to aim with a pointer to the beginning of the list all the time, even if I change it or remove it, but I don know how. I'm kind of new to this.
This is the full code I have, with functions to insert and remove the elements in the list as well with a function for instructions and to print
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
struct listNode {
char data;
struct listNode *nextPtr;
};
typedef struct listNode LISTNODE;
typedef LISTNODE *LISTNODEPTR;
char delete(LISTNODEPTR *, char);
int isEmpty(LISTNODEPTR);
void printList(LISTNODEPTR);
void instructions(void);
LISTNODE *addtoList(LISTNODEPTR *sPtr, char value);
int main() {
LISTNODEPTR startPtr = NULL;
int choice;
char item;
instructions();
printf("? ");
scanf("%d", &choice);
while (choice != 3) {
switch (choice) {
case 1:
printf("Enter a character: ");
scanf("\n%c", &item);
insert(&startPtr, item);
printList(startPtr);
break;
case 2:
if (!isEmpty(startPtr)) {
printf("Enter character to be deleted: ");
scanf("\n%c", &item);
if (delete (&startPtr, item)) {
printf("%c deleted.\n", item);
printList(startPtr);
} else
printf(
"List is empty or the element doesn´t exist.\n\n");
break;
default:
printf("Invalid choice.\n\n");
instructions();
break;
}
}
printf("? ");
scanf("%d", &choice);
}
printf("End of run.\n");
return 0;
}
void instructions(void) {
printf(
"Enter your choice:\n"
"1 to insert an element into the list.\n"
"2 to delete an element from the list.\n"
"3 to end.\n");
}
char delete(LISTNODEPTR *sPtr, char value) {
LISTNODEPTR previousPtr, currentPtr, tempPtr;
// if (value == (*sPtr)->data){
if (value == (*sPtr)->data) {
tempPtr = *sPtr;
*sPtr = (*sPtr)->nextPtr;
free(tempPtr);
return value;
} else {
previousPtr = *sPtr;
currentPtr = (*sPtr)->nextPtr;
while (currentPtr != NULL && currentPtr->data != value) {
previousPtr = currentPtr;
currentPtr = currentPtr->nextPtr;
}
if (currentPtr != NULL) {
tempPtr = currentPtr;
previousPtr->nextPtr = currentPtr->nextPtr;
free(tempPtr);
return value;
}
}
return '\0';
}
int isEmpty(LISTNODEPTR sPtr) { return sPtr == NULL; }
void printList(LISTNODEPTR currentPtr)
{
if (currentPtr == NULL) printf("List is empty. \n\n");
while (currentPtr != NULL) {
printf("%p %c -->", currentPtr, currentPtr->data);
currentPtr = currentPtr->nextPtr;
}
printf("NULL\n\n");
}
LISTNODE *addtoList(LISTNODE *sPtr, char value)
{
LISTNODE* temp = malloc(sizeof(LISTNODE));
if(temp == NULL)
{
printf("%d not inserted. No memory available.\n", value);
exit(0);
}
else
{
temp->data = value;
temp->nextPtr = NULL;
}
if(sPtr == NULL)
{
sPtr = temp;
return sPtr;
}
else
if(sPtr != NULL && sPtr->nextPtr == NULL)
{
sPtr->nextPtr = temp;
return sPtr;
}
else
if (sPtr != NULL && sPtr->nextPtr != NULL)
{
LISTNODE* Head = sPtr;
while(Head->nextPtr != NULL)
{
Head = Head->nextPtr;
}
Head->nextPtr = temp;
return sPtr;
}
else
{
printf("Unknown state of List\n\n");
exit(0);
}
}

Answer 1

With a circular list keeping track of the tail seems to have the fewest special cases and allows insertion at the front or back and deletion of the front in O(1). Deleting a node requires getting hold of their previous node. So iteration is best done with a pointer to the previous node kept in store.
So I made 2 structs: A ListNode that holds a pointer to the next node and the data. And a List that holds a pointer to the tail of the list. Although what the tail is in a circular list is arbitrary.
Operations on lists are always done by passing a List * in case the List.tail has to be updated. Operations that do not change the list take a const List *, e.g. printList().
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
typedef struct ListNode
{
struct ListNode *next;
char data;
} ListNode;
typedef struct List
{
ListNode *tail;
} List;
bool isEmpty(const List *list)
{
return list->tail == NULL;
}
void printList(const List *list)
{
if (isEmpty(list)) {
printf("List is empty.\n\n");
return;
}
// iteration works by keeping a pointer to the previous node
// so we start at the tail to print the first node
// it ends when the tail has been visited
ListNode *p = list->tail;
do {
p = p->next;
printf("%p %c -->", p, p->data);
} while(p != list->tail);
printf("\n\n");
}
char delete(List *list, char value)
{
if (isEmpty(list)) return '\0';
ListNode *p = list->tail;
do {
ListNode *q = p->next;
if (q->data == value) {
// remove q from list
p->next = q->next;
// are we removing the last node?
if (p == q) list->tail = NULL;
// if q is the tail set the tail to the previous node
if (list->tail == q) list->tail = p;
free(q);
return value;
}
p = q;
} while(p != list->tail);
return '\0';
}
// add value to the end of the list
void insert(List *list, char value)
{
// allocate node
ListNode *node = malloc(sizeof(ListNode));
if (node == NULL)
{
printf("'%c' not inserted. No memory available.\n", value);
exit(0);
}
node->data = value;
// if list is empty point the tail at the new node
if (isEmpty(list)) {
list->tail = node;
}
// point the node at the head of the list
node->next = list->tail->next;
// point the tail node at the new node
list->tail->next = node;
// update the tail to the new node
list->tail = node;
}
void instructions(void);
int main() {
List list = { NULL };
int choice;
char item;
instructions();
do {
printf("? ");
scanf("%d", &choice);
switch (choice) {
case 1:
printf("Enter a character: ");
scanf("\n%c", &item);
insert(&list, item);
printList(&list);
break;
case 2:
if (!isEmpty(&list)) {
printf("Enter character to be deleted: ");
scanf("\n%c", &item);
if (delete (&list, item)) {
printf("'%c' deleted from list.\n", item);
printList(&list);
} else {
printf("'%c' not found in list.\n", item);
}
} else {
printf("List is empty.\n\n");
}
break;
case 3:
break;
default:
printf("Invalid choice.\n\n");
instructions();
break;
}
} while (choice != 3);
printf("End of run.\n");
return 0;
}
void instructions(void)
{
printf(
"Enter your choice:\n"
"1 to insert an element into the list.\n"
"2 to delete an element from the list.\n"
"3 to end.\n");
}