Distributing tasks to players hangs program - c++

Question

We were given two structs, one representing a Player and another one representing a Task that the player can later implement after it has been assigned to him. Each player has a list of tasks sorted in ascending order. Initially we had to implement a circular doubly linked list with sentinel for the Players list and a singly sorted linked list with sentinel for the tasks (using the tasks_head & tasks_sentinel fields of the Players struct).
Once the data structures are set, we need to distribute the tasks from a given General tasks list (pointed to by Head_GL) to the players using a round robin algo (don't know if my solution is correct, haven't researched the algorithm so that i can try solving the problem on my own first).
The issue is that for some unknown to me reason, the program seems to hang when the isTaskListEmpty(..) is called and then the program stops just like that, without printing anything after cout<<"istasklist empty called";.
Any ideas on what i'm doing wrong?
P.S. I've never worked with c++ on anything other than simple hello world programs so my experience with pointers is beyond limited.
Header file declarations for the structs and some global variables:
/**
* Structure defining a node of the players double linked list
* tree
*/
struct Players
{
int pid; /*Player's identifier*/
int is_alien; /*Alien flag*/
int evidence; /*Amount of evidence*/
struct Players *prev; /*Pointer to the previous node*/
struct Players *next; /*Pointer to the next node*/
struct Tasks *tasks_head; /*Pointer to the head of player's task list*/
struct Tasks *tasks_sentinel; /*Pointer to the sentinel of player's task list*/
};
/**
* Structure defining a node of the tasks sorted linked list
*/
struct Tasks
{
int tid; /*Task's identifier*/
int difficulty; /*Task's difficulty*/
struct Tasks *next; /*Pointer to the next node*/
};
struct Head_GL
{
int tasks_count[3]; /*Count of tasks*/
struct Tasks *head; /*Pointer to the head of general list*/
};
/* Global variable, pointer to the head of the players list */
struct Players *players_head;
/* Global variable, pointer to the head of the tasks list */
struct Head_GL *tasks_head;
/* Global variable, pointer to the top of the completed task's stack */
struct Head_Completed_Task_Stack *tasks_stack;
/* Global variable, counter of the total num of tasks in the general tasks list */
int Total_Tasks;
Main.cpp:
/**
* #brief Optional function to initialize data structures that
* need initialization
*
* #return 1 on success
* 0 on failure
*/
int initialize() {
// players list init
players_head = (struct Players*) malloc(sizeof(struct Players));
players_head->evidence = -1;
players_head->is_alien = -1;
players_head->pid = -1;
players_head->next = NULL;
players_head->prev = NULL;
players_head->tasks_head = NULL;
players_head->tasks_sentinel = NULL;
// General Tasks List init
tasks_head = (struct Head_GL*) malloc(sizeof(struct Head_GL));
tasks_head->tasks_count[0] = 0;
tasks_head->tasks_count[1] = 0;
tasks_head->tasks_count[2] = 0;
tasks_head->head = NULL;
// Completed Tasks stack init
tasks_stack = (struct Head_Completed_Task_Stack*) malloc(sizeof(struct Head_Completed_Task_Stack));
tasks_stack->count = 0;
tasks_stack->head = NULL;
Total_Tasks = 0;
return 1;
}
/**
* #brief Distribute tasks to the players
* #return 1 on success
* 0 on failure
*/
int distribute_tasks() {
if(isDLLEmpty() || isGenTaskListEmpty()) return 0;
// round robin algo
int tasksToAssign;
struct Players* player = players_head->next; // start with the 1st player
struct Tasks* task = tasks_head->head; // start with the 1st task
// There's only one player and he's an impostor so exit
if(player->is_alien == 1 && player->next == NULL) return 0;
for(tasksToAssign = Total_Tasks; tasksToAssign > 0; tasksToAssign--) {
if(player->is_alien == 1 || player == players_head) {
tasksToAssign++;
player = player->next; // go to the next player
continue; // skip impostors
}
sortedInsertTaskList(&player,task->tid,task->difficulty);
player = player->next; // go to the next player
task = task->next; // go to the next task to assign
}
return 1;
}
// Beginning of General Tasks list implementation (Sorted singly linked list)
bool isGenTaskListEmpty() {
return (tasks_head->head == NULL);
}
int sortedInsertGenTaskList(int tid, int difficulty) {
// increment the list's difficulty counter
if (difficulty == 1) tasks_head->tasks_count[0]++;
else if (difficulty == 2) tasks_head->tasks_count[1]++;
else tasks_head->tasks_count[2]++;
Total_Tasks++; // increment the num of total tasks
struct Tasks *node = (struct Tasks*) malloc(sizeof(struct Tasks)); // could return null if not enough mem
if(node == NULL) return 0; // not enough memory exit
// add data to the new node
node->tid = tid;
node->difficulty = difficulty;
node->next = NULL;
if(isGenTaskListEmpty()) {
tasks_head->head = node;
return 1;
}
// insert the new node without breaking the sorting of the list
Tasks *curr = tasks_head->head;
while(curr->next != NULL && curr->next->difficulty < difficulty) {
curr = curr->next;
}
node->next = curr->next;
curr->next = node;
return 1;
}
void printGenTasksList() {
cout << "{" << tasks_head->tasks_count[0] << "," << tasks_head->tasks_count[1] << "," << tasks_head->tasks_count[2] << "}" << endl;
Tasks* curr = tasks_head->head;
do {
cout << "Task#" << curr->tid << ":" << curr->difficulty << endl;
curr = curr->next;
} while (curr != NULL);
}
// End of General Tasks list implementation (Sorted singly linked list)
// Beginning of Tasks List implementation (Sorted Singly Linked List w/sentinel)
bool isTaskListEmpty(struct Tasks* head) {
cout<<"istasklist empty called";
return (head->next == NULL);
}
int sortedInsertTaskList(struct Players** player, int tid, int difficulty) {
struct Tasks* node = (struct Tasks*) malloc(sizeof(struct Tasks)); // could return null if not enough mem
if(node == NULL) return 0;
// add data to the new node
node->tid = tid;
node->difficulty = difficulty;
node->next = NULL;
cout << "sortedInsert before is empty";
if (isTaskListEmpty((*player)->tasks_head)) { // if the list is empty, make the head and sentinel point to the new node
cout << "list was empty";
(*player)->tasks_head->next = node;
(*player)->tasks_sentinel->next = node;
return 1;
}
// check if the new node can be added to the end of the list
if ((*player)->tasks_sentinel->next->difficulty <= difficulty) {
(*player)->tasks_sentinel->next->next = node; // place new node at the end of the list
(*player)->tasks_sentinel->next = node; // update sentinel
return 1;
}
// insert the new node without breaking the sorting of the list
struct Tasks* curr = (*player)->tasks_head->next;
while (curr->next != NULL && curr->next->difficulty < difficulty) {
curr = curr->next;
}
node->next = curr->next;
curr->next = node;
return 1;
}
// End of Tasks List implementation (Sorted Singly Linked List w/sentinel)
// Beginning of players list implementation (circular doubly linked list w/ Sentinel)
bool isDLLEmpty() {
return (players_head->next == NULL);
}
int dllInsert(int pid, int isAlien) {
// allocate memory and initialize fields
struct Players* player = (struct Players*) malloc(sizeof(struct Players)); // could return null if not enough mem
if(player == NULL) return 0; // not enough memory, exit
player->pid = pid;
player->is_alien = isAlien;
player->evidence = 0;
player->prev = players_head;
player->tasks_head = NULL;
player->tasks_sentinel = NULL;
// check if the list is empty
if (isDLLEmpty()) {
player->next = players_head;
players_head->next = player;
players_head->prev = player;
return 1;
}
// insert the new player at the beginning of the list
players_head->next->prev = player;
player->next = players_head->next;
players_head->next = player;
return 1;
}
// End of players list implementation (circular doubly linked list w/ Sentinel)