//---------------------------------------------------------------------------------------------------------------------------------------
//3.Worst-fit decreasing algorithm using Linear Search. ---------------------------------------------------------------------------------
//Merge Sort Function: Used to sort the class Names_Durations which has list of names and list of durations of the audio files decreasing.
//Overall Complexity: O(N log N)
private static Names_Durations MergeSort(Names_Durations unsorted)
{
if (unsorted.duration.Count <= 1)
{
return(unsorted);
}
Names_Durations left = new Names_Durations();
Names_Durations right = new Names_Durations();
int middle = unsorted.duration.Count / 2;
for (int i = 0; i < middle; i++) //Dividing the unsorted list
{
left.name.Add(unsorted.name[i]);
left.duration.Add(unsorted.duration[i]);
}
for (int i = middle; i < unsorted.duration.Count; i++)
{
right.name.Add(unsorted.name[i]);
right.duration.Add(unsorted.duration[i]);
}
left = MergeSort(left);
right = MergeSort(right);
return(Merge(left, right));
}
//Button: Worst-fit decreasing algorithm using Linear Search.
//Overall Complexity: First for loop(𝞱(N))+Max(Merge Sort(O(N log N)),Second for loop(𝞱(N*M))+Create(𝞱(1))+MetaData(𝞱(N+M))+Copy(𝞱(N+M))) =.O(Max(N log N,N*M)).
private void button4_Click(object sender, EventArgs e)
{
Stopwatch StpW = Stopwatch.StartNew();
Names_Durations list = new Names_Durations();
for (int i = 0; i < durations.Count; i++)//First for loop:𝞱(N)
{
list.name.Add(names[i]);
list.duration.Add(durations[i]);
}
Names_Durations NewList = MergeSort(list);//O(N log N)
List <folder> folders = new List <folder>();
folder tempfolder = new folder();
tempfolder.folder_name = "F1";
tempfolder.totalremainduration = duration_each_folder - NewList.duration[0];
tempfolder.number_files = 1;
tempfolder.files_names.Add(NewList.name[0]);
tempfolder.files_Durations.Add(NewList.duration[0]);
folders.Add(tempfolder);
for (int i = 1; i < NewList.duration.Count; i++) //Overall Complexity of the Second for loop:𝞱(N*M),Number of the iteration=N
{
int max_folder_index = maxfolder(folders); //𝞱(M)
if (NewList.duration[i] <= folders[max_folder_index].totalremainduration) //𝞱(1)
{
folders[max_folder_index].totalremainduration -= NewList.duration[i];
folders[max_folder_index].files_names.Add(NewList.name[i]);
folders[max_folder_index].files_Durations.Add(NewList.duration[i]);
folders[max_folder_index].number_files++;
}
else//𝞱(1)
{
folder tempfolder2 = new folder();
tempfolder2.folder_name = "F" + (folders.Count + 1).ToString();
tempfolder2.totalremainduration = duration_each_folder - NewList.duration[i];
tempfolder2.files_names.Add(NewList.name[i]);
tempfolder2.files_Durations.Add(NewList.duration[i]);
tempfolder2.number_files = 1;
folders.Add(tempfolder2);
}
}
string FolderName = "[2] WorstFit Decreasing";
Create(FolderName); //𝞱(1)
METADATA(folders); //𝞱(N+M)
StpW.Stop();
MessageBox.Show(StpW.Elapsed.ToString());
Copy(folders);//𝞱(N+M)
MessageBox.Show("Done !");
}
//folder filling algorithm
/*
* -complexity of exactlySum 𝞱(N*D)
* -exactlySum is called inside while loop when there is more audios
* -overall of folder filling of while loop inside folder filling button
* -complexity 𝞱(D*N^2)
* -Where D is duration of each folder and N is number of audio files
*/
private void button10_Click(object sender, EventArgs e)
{
Stopwatch StpW = Stopwatch.StartNew();
Names_Durations obj = new Names_Durations();
for (int i = 0; i < durations.Count; i++)//𝞱(N)
{
obj.name.Add(names[i]);
obj.duration.Add(durations[i]);
}
List <folder> folders = new List <folder>();
while (true) //O(N^2*D)
{
if (obj.duration.Count == 0)
{
break; //𝞱(1)
}
Names_Durations answer = exactlySum(ref obj, obj.duration.Count, (int)duration_each_folder); //𝞱(N*D)
if (answer.duration.Count == 0)
{
break; //𝞱(1)
}
folder tempfolder2 = new folder();
tempfolder2.folder_name = "F" + (folders.Count + 1).ToString();
tempfolder2.totalremainduration = 0;
tempfolder2.totalremainduration = duration_each_folder;
for (int i = 0; i < answer.duration.Count; i++)//O(N)
{
tempfolder2.files_names.Add(answer.name[i]);
tempfolder2.files_Durations.Add(answer.duration[i]);
tempfolder2.totalremainduration -= answer.duration[i];
}
folders.Add(tempfolder2);
}
string FolderName = "[4] FolderFilling";
Create(FolderName);
METADATA(folders);//𝞱(N+M)
StpW.Stop();
MessageBox.Show(StpW.Elapsed.ToString());
Copy(folders); //𝞱(N+M)
MessageBox.Show("Done !");
}
//---------------------------------------------------------------------------------------------------------------------------------------
//4.Worst-fit decreasing algorithm using Priority queue. --------------------------------------------------------------------------------
//Button: Worst-fit decreasing algorithm using Priority queue.
/*Overall Complexity:First for loop(𝞱(N))+Max(Merge Sort(O(N log N)),Second for loop(𝞱(N log M))+traverse(𝞱(N+M))+traverse_copy(𝞱(N+M)))
* =𝞱(N)+Max(N log N,N log M)=O(N log N) */
private void button6_Click(object sender, EventArgs e)
{
Stopwatch StpW = Stopwatch.StartNew();
folder_name = "[2] WorstFit Decreasing";
Names_Durations list = new Names_Durations();
for (int i = 0; i < durations.Count; i++)//First for loop:𝞱(N)
{
list.name.Add(names[i]);
list.duration.Add(durations[i]);
}
Names_Durations NewList = MergeSort(list);//O(N log N)
int count = 2;
double duration_of_each_file = double.Parse(textBox1.Text);
Node node = new Node(duration_of_each_file - NewList.duration[0], "F1");
node.list_names.Add(NewList.name[0]);
node.list_durations.Add(NewList.duration[0]);
max_binary_heap h = new max_binary_heap(node);
for (int i = 1; i < NewList.duration.Count; i++) //Overall Complexity of the Second for loop:𝞱(N log M),Number of iteration = N
{
if (h.root.total_remaining_time >= NewList.duration[i]) //Overall Complexity:𝞱(log M)
{
h.root.list_names.Add(NewList.name[i]);
h.root.list_durations.Add(NewList.duration[i]);
h.root.total_remaining_time -= NewList.duration[i];
h.max_heapify1(h.root);//𝞱(log M)
}
else//Overall Complexity:𝞱(log M)
{
node = new Node(duration_of_each_file - NewList.duration[i], "F" + count.ToString());
node.list_names.Add(NewList.name[i]);
node.list_durations.Add(NewList.duration[i]);
count++;
h.insert(node);//𝞱(log M)
}
}
// h.traverse(double.Parse(textBox1.Text));//𝞱(N+M)
StpW.Stop();
MessageBox.Show(StpW.Elapsed.ToString());
// h.traverse_Copy(double.Parse(textBox1.Text));//𝞱(N+M)
MessageBox.Show("Done !");
}
private static Names_Durations Merge(Names_Durations left, Names_Durations right)
{
Names_Durations result = new Names_Durations();
while (left.duration.Count > 0 || right.duration.Count > 0)
{
if (left.duration.Count > 0 && right.duration.Count > 0)
{
if (left.duration.First() >= right.duration.First()) //Comparing First two elements to see which is bigger
{
result.duration.Add(left.duration.First());
result.name.Add(left.name.First());
left.name.Remove(left.name.First());//Rest of the list minus the first element
left.duration.Remove(left.duration.First());
}
else
{
result.duration.Add(right.duration.First());
result.name.Add(right.name.First());
right.name.Remove(right.name.First());//Rest of the list minus the first element
right.duration.Remove(right.duration.First());
}
}
else if (left.duration.Count > 0)
{
result.duration.Add(left.duration.First());
result.name.Add(left.name.First());
left.duration.Remove(left.duration.First());
left.name.Remove(left.name.First());
}
else if (right.duration.Count > 0)
{
result.duration.Add(right.duration.First());
result.name.Add(right.name.First());
right.duration.Remove(right.duration.First());
right.name.Remove(right.name.First());
}
}
return(result);
}
//---------------------------------------------------------------------------------------------------------------------------------------
//6.Folder filling algorithm. -----------------------------------------------------------------------------------------------------------
public static Names_Durations exactlySum(ref Names_Durations items, int N, int D)
{
Names_Durations answer = new Names_Durations();
Names_Durations NewItems = new Names_Durations();
N = items.duration.Count;
bool[,] dp = new bool[N + 1, D + 1];
dp[0, 0] = true;
if (items.duration[0] <= D)
{
dp[0, (int)items.duration[0]] = true; //𝞱(1)
}
for (int i = 1; i < N; i++) //O(N*D) where D is duration of each folder
// N is number of audio files
{
for (int j = 0; j <= D; j++) //𝞱(D)
{
if (dp[i - 1, j] == true)
{
dp[i, j] = true;
}
if (dp[i - 1, j] == true && items.duration[i] + j <= D)
{
dp[i, (int)(j + items.duration[i])] = true;
}
}
}
int K = 0;
for (int j = D; j >= 0; j--)//O(D)
{
if (dp[N - 1, j] == true)
{
K = j;
break;
}
}
for (int i = N - 1; i >= 1; i--)//𝞱(N)
{
if (K - items.duration[i] >= 0)
{
if (dp[i - 1, (int)(K - items.duration[i])] == true)
{
K -= (int)items.duration[i];
answer.duration.Add(items.duration[i]);
answer.name.Add(items.name[i]);
}
else
{
NewItems.duration.Add(items.duration[i]);
NewItems.name.Add(items.name[i]);
}
}
else
{
NewItems.duration.Add(items.duration[i]);
NewItems.name.Add(items.name[i]);
}
}
if (K != 0)//𝞱(1)
{
answer.duration.Add(items.duration[0]);
answer.name.Add(items.name[0]);
}
else //𝞱(1)
{
NewItems.duration.Add(items.duration[0]);
NewItems.name.Add(items.name[0]);
}
items = NewItems;
return(answer);
}
//---------------------------------------------------------------------------------------------------------------------------------------
//5.First-fit decreasing algorithm using Linear Search. ---------------------------------------------------------------------------------
//Button: First-fit decreasing algorithm using Linear Search.
/*Overall Complexity: First for loop(𝞱 (N))+ 𝞱 (Max(Merge(O(N log N)),Second for loop(𝞱(N*M))))+Create(𝞱(1))+METADATA(𝞱(N+M))+Copy(𝞱(N+M)) =
* =𝞱 (Max(Merge(𝞱(N log N)),Second for loop(𝞱(N*M)))) = O(Max(N log N,N*M)).*/
private void button9_Click(object sender, EventArgs e)
{
Stopwatch StpW = Stopwatch.StartNew();
Names_Durations list = new Names_Durations();
for (int i = 0; i < durations.Count; i++)//First for loop:𝞱 (N)
{
list.name.Add(names[i]);
list.duration.Add(durations[i]);
}
Names_Durations NewList = MergeSort(list);//O(N log N)
List <folder> folders = new List <folder>();
folder folder1 = new folder();
folder1.folder_name = "F1";
folder1.totalremainduration = duration_each_folder - NewList.duration[0];
folder1.number_files = 1;
folder1.files_names.Add(NewList.name[0]);
folder1.files_Durations.Add(NewList.duration[0]);
folders.Add(folder1);
for (int i = 1; i < NewList.duration.Count; i++)//Secong for loop:𝞱(N*M),Number of iteration= N
{
bool flag = false;
for (int j = 0; j < folders.Count; j++) //𝞱(M),Number of iteration M
{
if (NewList.duration[i] <= folders[j].totalremainduration) //𝞱(1)
{
folders[j].totalremainduration -= NewList.duration[i];
folders[j].files_names.Add(NewList.name[i]);
folders[j].files_Durations.Add(NewList.duration[i]);
folders[j].number_files++;
flag = true;
break;
}
}
if (flag == false)//𝞱(1)
{
folder New_folder = new folder();
New_folder.folder_name = "F" + (folders.Count + 1).ToString();
New_folder.totalremainduration = duration_each_folder - NewList.duration[i];
New_folder.files_names.Add(NewList.name[i]);
New_folder.files_Durations.Add(NewList.duration[i]);
New_folder.number_files = 1;
folders.Add(New_folder);
flag = true;
}
}
string FolderName = "[3] FirstFit Decreasing";
Create(FolderName); //𝞱(1)
METADATA(folders); //𝞱(N+M)
StpW.Stop();
MessageBox.Show(StpW.Elapsed.ToString());
Copy(folders);//𝞱(N+M)
MessageBox.Show("Done !");
}
