Finish

Author: tahoe01

Report.md

@@ -99,7 +99,7 @@ void spin_the_bottle_sort(std::vector<int>& nums) {
                 swap_element(nums[i], nums[s]);
             }
         }
-    } 
+    }
 }
 ```
 
@@ -129,6 +129,7 @@ void shell_sort(std::vector<int>& nums, const std::vector<int>& gaps) {
 ```
 
 ### Annealing sort
+
 Inspired by simulated annealing meta-heuristic, which involves solving a problem by a sequence of choices from the nubmer of r_j neighbors and T_j distance.
 
 Pseudocode:
@@ -185,7 +186,7 @@ For annealing sort, it is tested over the following temparature and repetition s
 
 * Annealing 3 (Temp 3: [1024, 512, 216, 128, 64, 32, 16, 8, 4, 2, 1, 0], Rep 3: [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 0])
 
-* Annealing 4 (Temp 4: [243, 81, 27, 9, 3, 0], Rep 4: [2, 2, 2, 2, 2, 0])
+* Annealing 4 (Temp 4: [1597, 987, 610, 377, 233, 144, 89, 55, 34, 21, 13, 8, 5, 3, 2, 1], Rep 4: [2, 2, 2, 2, 2, 2, 2, 2,2, 2, 2, 2, 2, 2, 2, 0])
 
 * Annealing 5 (Temp 5: [256, 64, 16, 4, 0], Rep 5: [5, 5, 5, 5, 0])
 
@@ -215,20 +216,43 @@ In this section, the input testing data is permuted using uniformly distributed
 
 4. The following graph shows the running time of annealing sort over all different temparature sequences and repetition sequences above:
 
-    ![shell sort](./uniform-annealing.png)
+    ![annealing sort](./uniform-annealing.png)
 
     The best two cases of annealing sort are: annealing 2 (orange line) and annealing 4 (red line). The lines of these two different parameters almost overlapped. Annealing 4 is a little bit better than annealing 2.
 
-    Annealing 4 has temparature sequence: [243, 81, 27, 9, 3, 0] and reqetition sequence: [2, 2, 2, 2, 2, 0]
+    Annealing 4 has temparature sequence: [1597, 987, 610, 377, 233, 144, 89, 55, 34, 21, 13, 8, 5, 3, 2, 1] and reqetition sequence: [2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0]
 
 ### Almost-sorted permutations
 
 In this section, the input testing data is almost sorted by independently choosing 2logn pairs, (i, j), where i and j are uniformly-chosen random integers in the range from 0 to n-1, and swap the numbers at positions i and j in the array/vector.
 
 1. The graph below shows the running time of different algorithms on increasing problem size.
 
+    ![almost sort](./almost-sort.png)
+
+    Among all the sorting algorithms tested, insertion sort is the fastest.
+
 2. Regression analysis of the running time experiements
 
+    ![almost regression](./almost-regression.png)
+
+    Regression analysis also shows insertion sort has the smallest slope on log-log scale which means it is the fastest.
+
 3. The following graph shows the running time of shell sort over all different gap sequences:
 
+    ![shell sort](./almost-shell.png)
+
+    The best two cases of shell sort are: shell 3 and shell 5. And shell 5 is even faster than shell 3. Overall, gap sequence: [200, 190, 180, 170, 160, 150] has the best performance.
+
 4. The following graph shows the running time of annealing sort over all different temparature sequences and repetition sequences:
+
+    ![annealing sort](./almost-annealing.png)
+
+    The best two cases of annealing sort are: annealing 2 and annealing 6.
+    Annealing 2 has a faster run time than annealing 6.
+
+    Annealing 2 has temparature sequence: [1000, 800, 600, 400, 200, 0] and reqetition sequence: [2, 2, 2, 2, 2, 0]
+
+## Conclusion
+
+Overall, annealing sort 4 is the fastest when input testing data is in uniformly distributed permutations. And insertion sort is the fastest when input testing data in almost-sorted permutations.

almost-annealing.png

@@ -26,8 +26,8 @@ vector<int> get_random_shuffled_int_vector(int n)
     vector<int> vec = vector<int>(n);
     for(int i = 0; i < n; i++)
         vec[i] = (i + 1);
-    // shuffle_vector(vec);
-    almost_sorted_vector(vec); // Use this line to generate almost sorted array
+    shuffle_vector(vec);
+    // almost_sorted_vector(vec); // Use this line to generate almost sorted array
     return vec;
 }
 
@@ -40,7 +40,7 @@ timing time_sort(int n, int reps, function<void(vector<int>&)> sort_algorithm)
     {
         rvec = get_random_shuffled_int_vector(n);
         double min_timing = DBL_MAX;
-        for (int j = 0; j < 1; j++) { // For each input vector, do 3 runs and take the smallest timing.
+        for (int j = 0; j < 3; j++) { // For each input vector, do 3 runs and take the smallest timing.
             clock_t c_start = clock();
             sort_algorithm(rvec);
             clock_t c_end = clock();
@@ -66,7 +66,7 @@ timing time_shell_sort(int n, int reps, const std::vector<int>& gaps)
     {
         rvec = get_random_shuffled_int_vector(n);
         double min_timing = DBL_MAX;
-        for (int j = 0; j < 1; j++) { // For each input vector, do 3 runs and take the smallest timing.
+        for (int j = 0; j < 3; j++) { // For each input vector, do 3 runs and take the smallest timing.
             clock_t c_start = clock();
             shell_sort(rvec, gaps);
             clock_t c_end = clock();
@@ -92,7 +92,7 @@ timing time_annealing_sort(int n, int reps, const std::vector<int>& temps, const
     {
         rvec = get_random_shuffled_int_vector(n);
         double min_timing = DBL_MAX;
-        for (int j = 0; j < 1; j++) { // For each input vector, do 3 runs and take the smallest timing.
+        for (int j = 0; j < 3; j++) { // For each input vector, do 3 runs and take the smallest timing.
             clock_t c_start = clock();
             annealing_sort(rvec, temps, repetitions);
             clock_t c_end = clock();

almost-regression.png

@@ -25,4 +25,4 @@ def plot_timings_from_file(fname_list):
     # plt.savefig('uniform-shell.png')
     plt.close()
 
-plot_timings_from_file(["bubble.csv", "insertion.csv", "spin.csv", "shell1.csv", "shell2.csv", "annealing2.csv", "annealing4.csv"])
+plot_timings_from_file(["bubble.csv", "insertion.csv", "spin.csv", "shell5.csv", "shell3.csv", "annealing2.csv", "annealing6.csv"])

almost-shell.png

@@ -30,7 +30,7 @@ def plot_regression_lines(fname):
         m, b = get_regression_line_coefficients(n, seconds)       
         plt.plot(x, m*x + b, label=f'{fname.rstrip(".csv")}: y ~ {round(m, 2)}x + {round(b, 2)}')
 
-    file_list = ["bubble.csv", "insertion.csv", "spin.csv", "shell1.csv", "shell2.csv", "annealing2.csv", "annealing4.csv"]
+    file_list = ["bubble.csv", "insertion.csv", "spin.csv", "shell5.csv", "shell3.csv", "annealing2.csv", "annealing6.csv"]
 
     # Plot graph
     plt.subplot(2, 1, 1)