Week 9 Code Examples

email_management_system.c

// email_management_system.c
// Tammy Zhong
// Implementation file for email management system functions
// Modified by Angela Finlayson
// (TODO)

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

#include "email_management_system.h"

// Function prototypes 
// ADD YOUR OWN FUNCTION PROTOTYPES HERE 
struct email *create_email(char sender[], char subject[], double size, 
    enum email_type type, enum priority_type priority) {

        struct email *new_email = malloc(sizeof(struct email));
        strcpy(new_email->sender, sender);
        strcpy(new_email->subject, subject);
        new_email->size = size;
        new_email->type = type;
        new_email->priority = priority;
        return new_email;
}

// Function definitions

// Creates a new empty email folder 
//(TODO)
struct folder *create_folder(char name[]) {
    struct folder *new_folder = malloc(sizeof(struct folder));
    strcpy(new_folder->name, name);
    new_folder->emails = NULL;
    new_folder->num_emails = 0;
    return new_folder;
}

// Add a new email to the folder at the head 
// Similar to previous lecture code insert_head
// (TODO)
void insert_email_at_head(struct folder *email_folder, char sender[], 
    char subject[], double size, enum email_type type, 
    enum priority_type priority) {
        struct email *new_email = create_email(sender, subject, size, type, priority);
        new_email->next = email_folder->emails;
        email_folder->emails = new_email;
        email_folder->num_emails++;
}

// Given a string, look for email where the subject is this string 
// (TODO)
struct email *search_email(struct folder *email_folder, char subject[]) {
    struct email *current = email_folder->emails; //head of the list
    while (current != NULL && strcmp(current->subject, subject) != 0) {
        current = current->next;
    }
    return current;
}

void free_list(struct email *head) {
    struct email *current = head;
    while (current != NULL) {
        head = head->next;
        free(current); 
        current = head;
    }
}

// Removes all emails from a folder
// clears and delete associated memory of folder and emails in it
void clear_folder(struct folder *email_folder) {
    free_list(email_folder->emails);
    free(email_folder);
}

// Remove email(s) with certain priority (e.g. filter out low priority emails)
void delete_email_of_priority(struct folder *email_folder, enum priority_type priority) {
    struct email *prev = NULL;
    struct email *current = email_folder->emails;

    while (current != NULL) {
        if(current->priority == priority) {
            //delete this node
            if (prev == NULL) {
                email_folder->emails = email_folder->emails->next;
                free(current);
                current = email_folder->emails;
            } else {
                prev->next = current->next;
                free(current);
                current = prev->next;
            }
           
        } else {
            prev = current;
            current = current->next;
        }
    }
    email_folder->num_emails--;
}

// Append emails from folder_2 after folder_1 and returns them in the one folder
// Assumption made here assumes not same subject email in folder_1 and folder_2
struct folder *merge_folders(char merged_folder_name[], 
    struct folder *folder_1, struct folder *folder_2) {
    // TODO: implement this function
    struct folder *merged_folder = create_folder(merged_folder_name);
    if (folder_1->emails == NULL) {
        merged_folder->emails = folder_2->emails;
        return merged_folder;
    }
    merged_folder->emails = folder_1->emails;
    struct email *current = merged_folder->emails;
    while (current->next != NULL) {
        current = current->next;
    }
    current->next = folder_2->emails;
    folder_1->emails = NULL;
    folder_2->emails = NULL;
    clear_folder(folder_1);
    clear_folder(folder_2);
    return merged_folder;
}

// Split emails in a given folder into 3 folders based on email type 
// keeping original ordering
// assumption: received, sent and draft are folders already malloc-ed and initialised
void split_folder(struct folder *given_folder, 
    struct folder *received, struct folder *sent, struct folder *draft) {
    // TODO: implement this function
    struct email *received_tail = NULL;
    struct email *sent_tail = NULL;
    struct email *draft_tail = NULL;
    struct email *current = given_folder->emails;
    while (current != NULL) {
        if (current->type == RECEIVED) {
            if (received->emails == NULL) {
                received->emails = current;
                received_tail = received->emails;
            }
            else {
                received_tail->next = current;
                received_tail = received_tail->next;
            }
        }
        if (current->type == SENT) {
            if (sent->emails == NULL) {
                sent->emails = current;
                sent_tail = sent->emails;
            }
            else {
                sent_tail->next = current;
                sent_tail = sent_tail->next;
            }
        }
        if (current->type == DRAFT) {
            if (draft->emails == NULL) {
                draft->emails = current;
                draft_tail = draft->emails;
            }
            else {
                draft_tail->next = current;
                draft_tail = draft_tail->next;
            }
        }
        struct email *temp = current->next;
        current->next = NULL;
        current = temp;
    }
    given_folder->emails = NULL;
    clear_folder(given_folder);
}

// returns number of emails in a given folder 
// (EXTENSION TODO: Improve this)
int count_emails(struct folder *email_folder) {
    int counter = 0;
    struct email *current = email_folder->emails;
    while (current != NULL) {
        counter++;
        current = current->next;
    }
    return counter;
}


// Your functions here (include function comments):


////////////////////////////////////////////////////////////////////////////////
//                              Provided Code                              //
////////////////////////////////////////////////////////////////////////////////

// Print/display all emails in folder 
// Similar to previous lecture code print_list
void print_emails(struct folder *email_folder) {
    printf("Folder Name: %s\n", email_folder->name);
    struct email *current = email_folder->emails;

    if (current == NULL) {
        printf("There are no emails in this folder.\n");
    }

    while (current != NULL) {
        printf("---\n");
        print_single_email(current);
        current = current->next;
    }
}

// Prints out details of a single email 
void print_single_email(struct email *email) {
    if (email == NULL) {
        printf("Email is NULL.\n");
        return;
    }

    printf("Sender: %s\n", email->sender);
    printf("Subject: %s\n", email->subject);
    printf("Size: %lfmb\n", email->size);
    printf("Type: ");
    if (email->type == RECEIVED) {
        printf("RECEIVED\n");
    } else if (email->type == SENT) {
        printf("SENT\n");
    } else if (email->type == DRAFT) {
        printf("DRAFT\n");
    } else {
        printf("UNKNOWN\n");
    }
    printf("Priority: ");
    if (email->priority == HIGH_PRIORITY) {
        printf("HIGH_PRIORITY\n");
    } else if (email->priority == NORMAL_PRIORITY) {
        printf("NORMAL_PRIORITY\n");
    } else if (email->priority == LOW_PRIORITY) {
        printf("LOW_PRIORITY\n");
    } else {
        printf("UNKNOWN\n");
    }
}

email_management_system.h

// email_management_system.h
// Tammy Zhong
// Header file for email management system functions
// Modified by Angela Finlayson
// (Provided)

// #defines
#define MAX_LEN 100

// enum definition
enum email_type {
    DRAFT,
    RECEIVED,
    SENT,
};

enum priority_type {
    LOW_PRIORITY,
    NORMAL_PRIORITY,
    HIGH_PRIORITY
};

// struct definitions
struct folder {
    char name[MAX_LEN];
    int num_emails; // to use later :)
    struct email *emails;
};

struct email {
    char sender[MAX_LEN];
    char subject[MAX_LEN];
    double size;
    enum email_type type;
    enum priority_type priority; 
    struct email *next;
};

// Creates a new empty email folder 
// (TODO)
struct folder *create_folder(char name[]);

// Add a new email to the folder at the head 
// (TODO)
void insert_email_at_head(struct folder *email_folder, char sender[], 
    char subject[], double size, enum email_type type, enum priority_type priority);

// Given a string, look for email where the subject is this string 
// (TODO)
struct email *search_email(struct folder *email_folder, char subject[]);

// Remove email(s) with certain priority (e.g. filter out low priority emails)
// (TODO)
void delete_email_of_priority(struct folder *email_folder, enum priority_type priority);

// Append emails from folder_2 after folder_1 and returns them in the one folder
// (TODO)
struct folder *merge_folders(char merged_folder_name[], 
    struct folder *folder_1, struct folder *folder_2);

// Split emails in a given folder into 3 folders based on email type 
// keeping original ordering
// (TODO)
void split_folder(struct folder *given_folder, 
    struct folder *received, struct folder *sent, struct folder *draft);

// Removes all emails from a folder
// (TODO)
void clear_folder(struct folder *email_folder); // leak-check demo

// Returns number of emails in a given folder 
// (PROVIDED - TODO CAN BE IMPROVED)
int count_emails(struct folder *email_folder);

// CHALLENGE at home for fun: Sort emails in folder based on size
// (slightly out of scope of COMP1511 - touches on sorting algorithms)
// (TODO)
void sort_emails(struct folder *email_folder);

// Prints out details of a single email 
// (PROVIDED)
void print_single_email(struct email *email);

// Print/display all emails in folder 
// (PROVIDED)
void print_emails(struct folder *email_folder);

main.c

// main.c
// Angela Finlayson 
// Uses the email management system to allow a user to create a folder
// and and emails (with not content) to it.
// Only works for 1 folder... 
// (Provided)

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

#include "email_management_system.h"

void print_instructions(void);
void handle_search(struct folder *current_folder);
void handle_add_email(struct folder *current_folder);
void trim_newline(char str[]);

int main(void) {
    struct folder *current_folder = create_folder("inbox");
    char command;

    print_instructions();
    printf("\nEnter command: ");
    while (scanf(" %c", &command) == 1 && command != 'q') {
        if (command == 'a') {
            handle_add_email(current_folder);
        } else if (command == 'p') {
            print_emails(current_folder);
        } else if (command == 'n') { 
            printf("Number of emails: %d\n", count_emails(current_folder));
        } else if (command == 's') {
            handle_search(current_folder);
        } else {
            printf("Unknown command. Try again.\n");
        }
        printf("\nEnter command: ");
    }
    printf("Exiting\n");
    clear_folder(current_folder);
    return 0;
}

// Prints instructions to users
void print_instructions(void) {
    printf("Email Manager - Command Interface\n");
    printf("Commands:\n");
    printf("a - Add a new email to the folder\n");
    printf("p - Print all emails in the folder\n");
    printf("n - Count emails in the folder\n");
    printf("s - Search for an email by subject\n");
    printf("q - Quit\n");
}

// Handles adding a new email to the folder
// Assumes no error checking needed
void handle_add_email(struct folder *current_folder) {
    char sender[MAX_LEN] = "";
    char subject[MAX_LEN]= "";
    double size;
    int priority, type;

    // Remove whitespace from buffer
    int whitespace_ch;
    while ((whitespace_ch = getchar()) != '\n' && whitespace_ch != EOF) {}

    printf("Enter sender: ");
    fgets(sender, MAX_LEN, stdin);
    trim_newline(sender);
    printf("Enter subject: ");
    fgets(subject, MAX_LEN, stdin);
    trim_newline(subject);
    printf("Enter size (in MB): ");
    scanf("%lf", &size);
    printf("Enter email type (0 for DRAFT, 1 for RECEIVED, 2 for SENT): ");
    scanf("%d", &type);
    printf("Enter priority (0 for LOW, 1 for NORMAL, 3 for HIGH): ");
    scanf("%d", &priority);
    insert_email_at_head(current_folder, sender, subject, size, type, priority);
    printf("Email added to folder '%s'.\n", current_folder->name);
}

// Handles searching for an email by subject in the folder
void handle_search(struct folder *current_folder) {
    char subject[MAX_LEN];
    
    // Remove whitespace from buffer
    int whitespace_ch;
    while ((whitespace_ch = getchar()) != '\n' && whitespace_ch != EOF) {}

    printf("Enter subject to search: ");
    fgets(subject, MAX_LEN, stdin);
    trim_newline(subject);
    
    struct email *found_email = search_email(current_folder, subject);
    if (found_email != NULL) {
        printf("Email found:\n");
        print_single_email(found_email);
    } else {
        printf("No email with subject '%s' found.\n", subject);
    }
}

// removes trailing newline character
void trim_newline(char str[]) {
    int len = strlen(str);
    if (len > 0 && str[len - 1] == '\n') {
        str[len - 1] = '\0';  
    }
}

prac_q1.c

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

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

int find_smallest(struct node *head) {
    // TODO: Write your solution here.
    int smallest_so_far = head->data;
    struct node *current = head;
    while (current != NULL) {
        if (current->data < smallest_so_far) {
            smallest_so_far = current->data;
        }
        current = current->next;
    }
    return smallest_so_far;
}

// Helper function to create a new node.
struct node *create_node(int data) {
    struct node *new = malloc(sizeof(struct node));
    new->data = data;
    new->next = NULL;
    return new;
}

// Helper function to free the list.
void free_list(struct node *head) {
    while (head != NULL) {
        struct node *temp = head;
        head = head->next;
        free(temp);
    }
}

int main(void) {
    // Test 1: 8 -> 3 -> 12 -> 5
    struct node *list1 = create_node(8);
    list1->next = create_node(3);
    list1->next->next = create_node(12);
    list1->next->next->next = create_node(5);

    printf("Test 1: Expected 3, Got %d\n", find_smallest(list1));

    // Test 2: -4 -> 7 -> 0 -> -9
    struct node *list2 = create_node(-4);
    list2->next = create_node(7);
    list2->next->next = create_node(0);
    list2->next->next->next = create_node(-9);

    printf("Test 2: Expected -9, Got %d\n", find_smallest(list2));

    // Test 3: 42
    struct node *list3 = create_node(42);

    printf("Test 3: Expected 42, Got %d\n", find_smallest(list3));

    // Test 4: 5 -> 5 -> 5
    struct node *list4 = create_node(5);
    list4->next = create_node(5);
    list4->next->next = create_node(5);

    printf("Test 4: Expected 5, Got %d\n", find_smallest(list4));

    free_list(list1);
    free_list(list2);
    free_list(list3);
    free_list(list4);

    return 0;
}

prac_q2.c

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

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

int is_square(int number) {
    if (number == 1) {
        return 1;
    }
    else {
        int n = number/2;
        int i = 0;
        while (i <= n) {
            if (i * i == number) {
                return 1;
            }
            i++;
        }
    }
    return 0;
}

// Returns the number of square numbers in the linked list.
int count_square_numbers(struct node *head) {
    // TODO: Write your solution here.
    struct node *current = head;
    int counter = 0;
    while (current != NULL) {
        if (is_square(current->data) == 1) {
            counter++;
        }
        current = current->next;
    }
    return counter;
}

// Helper function to create a new node.
struct node *create_node(int data) {
    struct node *new = malloc(sizeof(struct node));
    new->data = data;
    new->next = NULL;
    return new;
}

// Helper function to free the list.
void free_list(struct node *head) {
    while (head != NULL) {
        struct node *temp = head;
        head = head->next;
        free(temp);
    }
}

int main(void) {
    // Test 1: 1 -> 2 -> 4 -> 5 -> 9
    struct node *list1 = create_node(1);
    list1->next = create_node(2);
    list1->next->next = create_node(4);
    list1->next->next->next = create_node(5);
    list1->next->next->next->next = create_node(9);

    printf("Test 1: Expected 3, Got %d\n", count_square_numbers(list1));

    // Test 2: 3 -> 7 -> 8 -> 10
    struct node *list2 = create_node(3);
    list2->next = create_node(7);
    list2->next->next = create_node(8);
    list2->next->next->next = create_node(10);

    printf("Test 2: Expected 0, Got %d\n", count_square_numbers(list2));

    // Test 3: 16
    struct node *list3 = create_node(16);

    printf("Test 3: Expected 1, Got %d\n", count_square_numbers(list3));

    // Test 4: -4 -> 0 -> 25 -> 26 -> 36
    struct node *list4 = create_node(-4);
    list4->next = create_node(0);
    list4->next->next = create_node(25);
    list4->next->next->next = create_node(26);
    list4->next->next->next->next = create_node(36);

    printf("Test 4: Expected 3, Got %d\n", count_square_numbers(list4));

    free_list(list1);
    free_list(list2);
    free_list(list3);
    free_list(list4);

    return 0;
}

prac_q3.c

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

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

// Returns the absolute difference in the number of nodes
// in the two linked lists.
int difference_in_length(struct node *head1, struct node *head2) {
    struct node *current = head1;
    int counter_1 = 0;
    while (current != NULL) {
        counter_1++;
        current = current->next;
    }
    current = head2;
    int counter_2 = 0;
    while (current != NULL) {
        counter_2++;
        current = current->next;
    }
    int difference = counter_1 - counter_2;
    if (difference < 0) {
        difference = difference * -1;
    }
    return difference;
}

// Helper function to create a new node.
struct node *create_node(int data) {
    struct node *new = malloc(sizeof(struct node));
    new->data = data;
    new->next = NULL;
    return new;
}

// Helper function to free a list.
void free_list(struct node *head) {
    while (head != NULL) {
        struct node *temp = head;
        head = head->next;
        free(temp);
    }
}

int main(void) {
    // Test 1: 3 nodes vs 5 nodes
    struct node *list1 = create_node(1);
    list1->next = create_node(2);
    list1->next->next = create_node(3);

    struct node *list2 = create_node(4);
    list2->next = create_node(5);
    list2->next->next = create_node(6);
    list2->next->next->next = create_node(7);
    list2->next->next->next->next = create_node(8);

    printf("Test 1: Expected 2, Got %d\n",
           difference_in_length(list1, list2));

    // Test 2: Equal lengths (4 vs 4)
    struct node *list3 = create_node(1);
    list3->next = create_node(2);
    list3->next->next = create_node(3);
    list3->next->next->next = create_node(4);

    struct node *list4 = create_node(5);
    list4->next = create_node(6);
    list4->next->next = create_node(7);
    list4->next->next->next = create_node(8);

    printf("Test 2: Expected 0, Got %d\n",
           difference_in_length(list3, list4));

    // Test 3: 1 node vs empty list
    struct node *list5 = create_node(42);
    struct node *list6 = NULL;

    printf("Test 3: Expected 1, Got %d\n",
           difference_in_length(list5, list6));

    // Test 4: Empty list vs 3 nodes
    struct node *list7 = NULL;

    struct node *list8 = create_node(9);
    list8->next = create_node(10);
    list8->next->next = create_node(11);

    printf("Test 4: Expected 3, Got %d\n",
           difference_in_length(list7, list8));

    free_list(list1);
    free_list(list2);
    free_list(list3);
    free_list(list4);
    free_list(list5);
    free_list(list6);
    free_list(list7);
    free_list(list8);

    return 0;
}

prac_q4.c

#include <stdio.h>

struct direction {
    int number;
    char dir;
};

// Returns the total number of steps taken in the given direction.
int total_steps(struct direction directions[], int size, char target_dir) {
    // TODO: Write your solution here.
    if (size == 0) {
        return 0;
    }
    int total = 0;
    int i = 0;
    while (i < size) {
        if (directions[i].dir == target_dir) {
            total += directions[i].number;
        }
        i++;
    }
    return total;
}

int main(void) {
    struct direction test1[] = {
        {3, 'l'},
        {5, 'r'},
        {2, 'l'},
        {4, 'u'},
        {1, 'l'}
    };

    printf("Test 1: Expected 6, Got %d\n",
           total_steps(test1, 5, 'l'));

    struct direction test2[] = {
        {2, 'u'},
        {3, 'u'},
        {1, 'd'},
        {4, 'u'}
    };

    printf("Test 2: Expected 9, Got %d\n",
           total_steps(test2, 4, 'u'));

    struct direction test3[] = {
        {7, 'r'},
        {5, 'l'},
        {2, 'd'}
    };

    printf("Test 3: Expected 0, Got %d\n",
           total_steps(test3, 3, 'u'));

    struct direction test4[] = {
        {10, 'd'}
    };

    printf("Test 4: Expected 10, Got %d\n",
           total_steps(test4, 1, 'd'));

    struct direction test5[] = {{}};

    int answer = total_steps(test5, 0, 'l');
    printf("Test 5: Expected 0, Got %d\n", answer);

    return 0;
}

prac_q5.c

#include <stdio.h>

// Returns the number of multiples of 4 in the 2D array.
int count_multiples_of_four(int rows, int cols, int array[rows][cols]) {
    // TODO: Write your solution here.
    int total = 0;
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            if (array[i][j] % 4 == 0) {
                total++;
            }
        }
    }
    return total;
}

int main(void) {
    int test1[4][5] = {
        {1, 4, 7, 8, 10},
        {12, 15, 16, 18, 20},
        {3, 5, 6, 9, 11},
        {24, 25, 28, 30, 32}
    };

    printf("Test 1: Expected 8, Got %d\n",
           count_multiples_of_four(4, 5, test1));

    int test2[3][4] = {
        {1, 2, 3, 5},
        {6, 7, 9, 10},
        {11, 13, 14, 15}
    };

    printf("Test 2: Expected 0, Got %d\n",
           count_multiples_of_four(3, 4, test2));

    int test3[2][6] = {
        {4, 8, 12, 16, 20, 24},
        {28, 32, 36, 40, 44, 48}
    };

    printf("Test 3: Expected 12, Got %d\n",
           count_multiples_of_four(2, 6, test3));

    int test4[3][3] = {
        {0, 1, 2},
        {4, 5, 6},
        {8, 9, 12}
    };

    printf("Test 4: Expected 4, Got %d\n",
           count_multiples_of_four(3, 3, test4));

    return 0;
}

test_main.c

// main.c
// Tammy Zhong
// Program to test email management system functions
// Modified by Angela Finlayson 9/11/2025
// (Provided)


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

#include "email_management_system.h"

int main(void) {
    // STAGE 1
    printf("*****1. Creating Folder 1...*****\n");
    struct folder *folder_1 = create_folder("Folder 1");

    printf("\n*****2. Number of emails in Empty Folder 1:*****\n");
    printf("%d\n", count_emails(folder_1));

    printf("\n*****3. Printing Empty Folder 1...*****\n");
    print_emails(folder_1);

    printf("\n*****4. Inserting emails in Empty Folder 1 *****\n");
 
    insert_email_at_head(folder_1, "Jon", "AAA", 10.2, RECEIVED, HIGH_PRIORITY);
    insert_email_at_head(folder_1, "Tim", "BBB", 20.44, DRAFT, NORMAL_PRIORITY);
    insert_email_at_head(folder_1, "Brianna", "CCC", 150.0, SENT, LOW_PRIORITY);
    insert_email_at_head(folder_1, "Tammy", "DDD", 90.2, SENT, NORMAL_PRIORITY);
    insert_email_at_head(folder_1, "Sofia", "EEE", 90.0, DRAFT, LOW_PRIORITY);

    printf("\n*****5. Printing Folder 1...*****\n");
    print_emails(folder_1); 

    printf("\n*****6. Number of emails in Folder 1: *****\n");
    printf("%d\n", count_emails(folder_1));
   
    
    printf("\n*****7. Look for email with subject 'AAA'...*****\n");
    struct email *email_found = search_email(folder_1, "AAA");
    
    printf("\n*****8. Printing email found in Folder 1 ...*****\n");
    print_single_email(email_found);

    printf("\n*****9. Look for email with subject 'DDD'...*****\n");
    email_found = search_email(folder_1, "DDD");
    
    printf("\n*****10. Printing email found in Folder 1 ...*****\n");
    print_single_email(email_found);

    printf("\n*****11. Look for email with subject 'EEE'...*****\n");
    email_found = search_email(folder_1, "EEE");
    
    printf("\n*****12. Printing email found in Folder 1 ...*****\n");
    print_single_email(email_found);

    printf("\n*****13. Look for email with subject 'Holiday'...*****\n");
    email_found = search_email(folder_1, "Holiday");
    
    printf("\n*****14. Printing email found in Folder 1 ...*****\n");
    print_single_email(email_found);
    

    printf("\n*****15. Creating Folder 2... and inserting emails...*****\n");
    struct folder *folder_2 = create_folder("Folder 2");
    insert_email_at_head(folder_2, "Liam", "E", 50.5, SENT, LOW_PRIORITY);
    insert_email_at_head(folder_2, "Sophie", "F", 5.97, RECEIVED, HIGH_PRIORITY);
    insert_email_at_head(folder_2, "Grace", "G", 30.28, SENT, NORMAL_PRIORITY);
    insert_email_at_head(folder_2, "Andrew", "H", 5.5, RECEIVED, LOW_PRIORITY);
    insert_email_at_head(folder_2, "Holly", "I", 25.25, RECEIVED, LOW_PRIORITY);
    insert_email_at_head(folder_2, "Ibby", "J", 15.25, RECEIVED, NORMAL_PRIORITY);
    insert_email_at_head(folder_2, "Bella", "K", 15.25, RECEIVED, LOW_PRIORITY);
    
    printf("\n*****16. Printing Folder 2...*****\n");
    print_emails(folder_2);
    
    //STAGE 2

    printf("\n*****17. Deleting LOW_PRIORITY emails from Folder 2...*****\n");
    delete_email_of_priority(folder_2, LOW_PRIORITY);
    
    printf("\n*****18. Printing Folder 2...*****\n");
    print_emails(folder_2);
  
    
    printf("\n*****19. Merging Folder 1 and Folder 2...*****\n");
    struct folder *merged_folder = merge_folders("Merged Folder", folder_1, 
                                                                  folder_2);
    
    printf("\n*****20. Printing merged folder...*****\n");
    print_emails(merged_folder);
    
    printf("\n*****21. Split merged folder into inbox, sent, draft...*****\n");
    struct folder *inbox = create_folder("inbox");
    struct folder *sent = create_folder("sent");
    struct folder *draft = create_folder("draft");
    split_folder(merged_folder, inbox, sent, draft);
    
    printf("\n*****22. Printing inbox...*****\n");
    print_emails(inbox);

    printf("\n*****23. Printing sent...*****\n");
    print_emails(sent);

    printf("\n*****24. Printing draft...*****\n");
    print_emails(draft);
    
    
    // STAGE 1: comment this section out once you implement merge
    //printf("\n*****Clearing stage 1 folders folder_1 and folder_2...*****\n");

    //clear_folder(folder_1);
    //clear_folder(folder_2);

    // STAGE 2 merge:  comment this section out once you implement split
    //printf("\n*****Clearing stage 2 merged_folder...*****\n");
    //clear_folder(merged_folder);

    // STAGE 2 
    printf("\n*****Clearing inbox, sent, draft (freeing all memory)...*****\n");
    clear_folder(inbox);
    clear_folder(sent);
    clear_folder(draft);
   
    
    return 0;
}