diff --git a/output_mp/test_5 b/output_mp/test_5
deleted file mode 100644
index 2734eef50f4aaad6b790f549ad5e2b729c8cdcdc..0000000000000000000000000000000000000000
--- a/output_mp/test_5
+++ /dev/null
@@ -1,4 +0,0 @@
-5
-0-1
-1-3
-2-4
diff --git a/src/MST_OpenMP b/src/MST_OpenMP
index e0b67dca12c01308f91b2c159833bcec277f3b76..60d489dac068a42ece5656c200418a05f0a484dc 100755
Binary files a/src/MST_OpenMP and b/src/MST_OpenMP differ
diff --git a/src/MST_OpenMP.c b/src/MST_OpenMP.c
index 29564c7e5e594f7fee83aa8669cc33591c83e2ea..d745f9e0afbcdfb8ee16d1c3d39943ee87fbb350 100644
--- a/src/MST_OpenMP.c
+++ b/src/MST_OpenMP.c
@@ -47,6 +47,22 @@ void PrintGraph(Graph *graph)
     }
 }
 
+int compare_src_dest(Edge P1, Edge P2){
+    if (P1.src < P2.src){
+        return -1;
+    } else if (P1.src == P2.src){
+        if (P1.dest < P2.dest){
+            return -1;
+        } else if (P1.dest > P2.dest){
+            return 1;
+        } else {
+            return 0;
+        }
+    } else {
+        return 1;
+    }
+}
+
 void PartisiSrc(Edge T[], int i, int j, int *k)
 {
     Edge pivot = T[i - 1];
@@ -54,11 +70,11 @@ void PartisiSrc(Edge T[], int i, int j, int *k)
     int q = j;
     while (p <= q)
     {
-        while (T[p - 1].src < pivot.src)
+        while (compare_src_dest(T[p-1], pivot) == -1)
         {
             p++;
         }
-        while (T[q - 1].src > pivot.src)
+        while (compare_src_dest(T[q-1], pivot) == 1)
         {
             q--;
         }
@@ -272,12 +288,12 @@ int compare(const void *a, const void *b)
     return a1->weight > b1->weight;
 }
 
-int compare_src(const void *a, const void *b)
-{
-    Edge *a1 = (Edge *)a;
-    Edge *b1 = (Edge *)b;
-    return a1->src > b1->src;
-}
+// int compare_src(const void *a, const void *b)
+// {
+//     Edge *a1 = (Edge *)a;
+//     Edge *b1 = (Edge *)b;
+//     return a1->src > b1->src;
+// }
 
 // Minimum Spanning Tree using Kruskal's Algorithm
 void KruskalMST(Graph *graph, Edge result[], int *e)
diff --git a/src/MST_OpenMPI b/src/MST_OpenMPI
index 46a1efd6b0b192b732dc4e9f325ca04bec9384e5..de27ed4ab6fa721918a3ef4ad35ba1366587da37 100755
Binary files a/src/MST_OpenMPI and b/src/MST_OpenMPI differ
diff --git a/src/MST_OpenMPI.c b/src/MST_OpenMPI.c
index 2fe891f20f920547ea6bf45e298a00b86f15d94c..d8b52058b7f268c0cf1e5c2cad0416b58bc8b4cb 100644
--- a/src/MST_OpenMPI.c
+++ b/src/MST_OpenMPI.c
@@ -136,6 +136,7 @@ void QuickSort(Edge T[], int i, int j, int rank, int max_rank, int rank_index){
     // If the rank of distributed process is higher than max rank
     if (distributed_process >= max_rank) {
         SequentialQuickSort(T, i, j);
+        // MPI_Send(&T, j - i+1, mpi_edge_type, distributed_process, 1, MPI_COMM_WORLD);
     }
     else {
         int pivot;
@@ -237,23 +238,25 @@ void Union(Subset subsets[], int x, int y)
     }
 }
 
-// Compare two edges according to their weights.
-int compare(const void *a, const void *b)
+int compare_src_dest(const void *a, const void *b)
 {
     Edge *a1 = (Edge *)a;
     Edge *b1 = (Edge *)b;
-    return a1->weight > b1->weight;
-}
-
-// Compare two sources according to their number
-int compare_src(const void *a, const void *b)
-{
-    Edge *a1 = (Edge *)a;
-    Edge *b1 = (Edge *)b;
-    return a1->src > b1->src;
+    if (a1->src < b1->src){
+        return 0;
+    } else if (a1->src == b1->src){
+        if (a1->dest < b1->dest){
+            return 0;
+        } else if (a1->dest > b1->dest){
+            return 1;
+        } else {
+            return 0;
+        }
+    } else {
+        return 1;
+    }
 }
 
-
 // Minimum Spanning Tree using Kruskal's Algorithm
 void KruskalMST(Graph *graph, Edge result[], int *e, int size, int rank)
 {
@@ -280,9 +283,7 @@ void KruskalMST(Graph *graph, Edge result[], int *e, int size, int rank)
         }
     }
 
-    // QuickSortSrc(graph->edge, 0, graph->E, size, rank);
-    // QuickSortSrc(result, 1, (*e));
-    qsort(result, *e, sizeof(result[0]), compare_src);
+    qsort(result, *e, sizeof(result[0]), compare_src_dest);
     return;
 }
 
@@ -347,16 +348,12 @@ int main()
 
         // Declare the array buffer to receive data from the source process
         Edge* temp = (Edge *) malloc (sizeof(Edge) *arrLength);
+
         source = MPI_Recv(temp, arrLength, mpi_edge_type, src, 1, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
-        printf("Process %d\n", rank);
         // Sort the received buffer with QuickSort
         QuickSort(temp, 1, arrLength, rank, size, idxcnt);
-        printf("Process %d\n", rank);
         // Send the sorted array back to the source process
         source = MPI_Send(temp, arrLength, mpi_edge_type, src, 1, MPI_COMM_WORLD);
-        
-        // source = MPI_Send(temp, arrLength, mpi_edge_type, src, 1, MPI_COMM_WORLD);
-        printf("Process %d\n", rank);
         free(temp);
     }
     MPI_Finalize();