Introduction:

The Playlist Management Application is a console-based

program that allows users to manage a playlist of songs.

The application provides functionality to add songs, remove

songs, display the playlist, shuffle the playlist, sort the
playlist, and search for songs within the playlist.

This documentation provides an overview of the project's

structure, the algorithms used, and instructions on how to use
the application.
Problem Statement:
Design and implement a program that manages a playlist of songs. The program
should allow the user to add songs to the playlist, remove songs from the playlist,
display the current playlist, shuffle the songs randomly, sort the songs in
ascending order, and search for a specific song in the playlist.

Design:
The program will use a linked list data structure to represent the playlist. Each
node in the linked list will store the title of a song and a pointer to the next song
in the playlist. The program will provide functions to perform operations on the
playlist such as adding a song, removing a song, displaying the playlist, shuffling
the playlist, sorting the playlist, and searching for a song.
Structure:

The linked list used in the project is a singly linked list, meaning each node only
has a reference to the next node.

The first node in the list is called the head, and it serves as the entry point for
accessing the list.

The last node is called the tail and has a null reference as its next pointer
The `Song` struct represents a node in the linked list. It contains two members:
1. `title`: A string that holds the title of the song.
2. `next`: A pointer to the next `Song` struct in the list.
Algorithms Used:
1. Adding a Song
2. Removing a Song
3. Displaying the Playlist
4. Shuffling the Playlist
5. Sorting the Playlist:
6. Searching for a Song:
Implementation:
1. Define a Song structure with members for the title and a pointer to the next song.
2. Implement functions for creating a song, adding a song to the playlist, removing a song
from the playlist, displaying the playlist, shuffling the playlist, sorting the playlist, and
searching for a song.
3. Use a linked list data structure to represent the playlist, where each node is a Song
object.
4. In the addSong function, create a new song and add it to the end of the playlist.
5. In the removeSong function, find the song with the given title and remove it from the
playlist.
6. In the displayPlaylist function, iterate through the playlist and display the
title of each song.
7. In the shufflePlaylist function, randomly rearrange the songs in the playlist.
8. In the sortPlaylist function, sort the songs in ascending order.
9. In the searchSong function, find and display the position of the song with the
given title in the playlist.
10. In the main function, create an empty playlist and provide a menu for the
user to interact with the playlist, including options to add, remove, display,
shuffle, sort, and search songs.
Analyzing the performance, time complexity, and space
complexity of the operations in the Playlist Management
Application
1. Adding a Song:

- Performance: Adding a song to the playlist involves creating a new

node and updating the pointers to link it at the end of the list. The
performance is generally fast and efficient.
- Time Complexity: O(1) - Constant time complexity. It does not depend
on the size of the playlist since we always add the song at the end.
- Space Complexity: O(1) - Constant space complexity. It only requires
memory for the new node
2. Removing a Song:
- Performance: Removing a song from the playlist involves traversing the
list to find the song, adjusting the pointers of neighboring nodes, and
deallocating the memory. The performance is generally efficient.
- Time Complexity: O(n) - Linear time complexity. In the worst case, we
need to traverse the entire playlist to find the song to be removed.
- Space Complexity: O(1) - Constant space complexity. It does not require
additional memory beyond the removed node.
5. Sorting the Playlist:
- Performance: Sorting the playlist involves creating an array, populating
the array, sorting it, and updating the playlist. The performance depends on
the size of the playlist but may be slower for large playlists.
- Time Complexity: O(n^2) - Quadratic time complexity. It uses a bubble
sort algorithm, which has a worst-case time complexity of O(n^2), where n
is the number of songs in the playlist.
- Space Complexity: O(n) - Linear space complexity. It requires
additional memory to hold the array of song titles, where n is the number
of songs in the playlist.
6. Searching for a Song:
- Performance: Searching for a song involves traversing the linked list
and comparing the titles of each song. The performance is generally
efficient.
- Time Complexity: O(n) - Linear time complexity. In the worst case, we
need to traverse the entire playlist to find the song.
- Space Complexity: O(1) - Constant space complexity. It does not
require additional memory beyond the variables used for comparison.
Overall, the Playlist Management Application performs well for most
operations. Adding and displaying songs have constant time complexity,
while removing and searching have linear time complexity. Shuffling and
sorting operations have linear time complexity but require additional
memory.
Strengths:
1. Linked list data structure allows efficient insertion and removal of songs
from the playlist.
2. Functions are available for adding, removing, displaying, shuffling, sorting,
and searching songs, providing a comprehensive set of operations for
managing the playlist.
3. The program uses dynamic memory allocation to create new songs,
allowing flexibility in the size of the playlist.
4. The shuffle and sort functions provide different ways to reorder the songs,
adding variety to the playlist.
5. The search function allows users to quickly find specific songs in the playlist.
Limitations:
1. The program does not handle duplicate songs. If a user tries to add a song with
the same title as an existing song, it will be added as a separate entry.
2. The program does not include features for managing song metadata such as
artist, album, or duration.
3. The shuffle function uses a basic randomization algorithm, which may not
produce truly random results.
4. The sort function uses a simple sorting algorithm like bubble sort, which may not
be efficient for large playlists.