Change algorithm to be iterative instead of recursive

Author: Royar13

LinkedList.c

@@ -6,7 +6,7 @@
  * Creates a new empty linked list.
  * @return a pointer to the new list.
  */
-LinkedList *createLinkedList(){
+LinkedList *createLinkedList() {
     LinkedList *list = malloc(sizeof(LinkedList));
     assertMemoryAllocation(list);
     list->length = 0;
@@ -18,7 +18,7 @@ LinkedList *createLinkedList(){
  * Does NOT free the pointers nodes are pointing to.
  * @param list a linked list.
  */
-void freeLinkedList(LinkedList *list){
+void freeLinkedList(LinkedList *list) {
     LinkedListNode *temp;
     LinkedListNode *node = list->first;
     if (node != NULL) {
@@ -36,11 +36,11 @@ void freeLinkedList(LinkedList *list){
  * It also destroys every group in the list.
  * @param list a linked list, containing pointers to VerticesGroups.
  */
-void deepFreeGroupList(LinkedList *groupList){
+void deepFreeGroupList(LinkedList *groupList) {
     LinkedListNode *node = groupList->first;
     VerticesGroup *group;
     int i;
-    for(i = 0; i < groupList->length; ++i){
+    for (i = 0; i < groupList->length; ++i) {
         group = node->pointer;
         freeVerticesGroup(group);
         node = node->next;
@@ -78,18 +78,19 @@ void *insertItem(LinkedList *list, void *pointer) {
  * @param list a linked list
  * @param item a LinkedListNode pointer to some item in 'list'.
  */
-void removeItem(LinkedList *list, LinkedListNode *item){
+void removeItem(LinkedList *list, LinkedListNode *item) {
     LinkedListNode *oldPrev = item->prev;
-    LinkedListNode  *oldNext = item->next;
-    if(list->length > 1){
-        oldPrev->next = oldNext;
-        oldNext->prev = oldPrev;
-        free(item);
-        list->length--;
-    }
-    else if(list->length == 1){
-        free(item);
-        list->first = NULL;
-        list->length = 0;
+    LinkedListNode *oldNext = item->next;
+    oldPrev->next = oldNext;
+    oldNext->prev = oldPrev;
+
+    if (item == list->first) {
+        if (list->length == 1) {
+            list->first = NULL;
+        } else {
+            list->first = oldNext;
+        }
     }
+    free(item);
+    list->length--;
 }

cluster.c

@@ -11,7 +11,7 @@
 
 #define FILE_PATH_MAX_LENGTH 200
 
-int cluster(int argc, char **argv) {
+int main(int argc, char **argv) {
     int i = 1, j;
     LinkedList *groupsLst;
     LinkedListNode *node;

division.c

@@ -6,6 +6,7 @@
 #include "defs.h"
 #include "ErrorHandler.h"
 #include "quicksort.h"
+#include "LinkedList.h"
 
 /**
  * Generate a random vector
@@ -120,19 +121,15 @@ double maximizeModularity(Graph *G, VerticesGroup *group, double *s, double init
  * @param vector an empty allocated array the size of the graph's vertices, used for power iteration
  * @param s an empty allocated array the size of the graph's vertices, used for storing an eigenvector
  */
-void divisionAlgRec(Graph *G, VerticesGroup *group, LinkedList *groupsLst, double *vector, double *s) {
-    VerticesGroup *newGroupA = NULL, *newGroupB = NULL;
+void divisionAlgorithm2(Graph *G, VerticesGroup *group, double *vector, double *s, VerticesGroup **newGroupA,
+                        VerticesGroup **newGroupB) {
     int i;
     double lambda, modularity, modularityAfterMax;
-    if (group->size == 1) {
-        insertItem(groupsLst, group);
-        return;
-    }
+
     calculateModularitySubMatrix(G, group);
     randVector(vector, group->size);
     lambda = powerIteration(G, group, vector, s);
     if (!IS_POSITIVE(lambda)) {
-        insertItem(groupsLst, group);
         return;
     }
     /* turn s eigenvector into +1 and -1 */
@@ -146,18 +143,11 @@ void divisionAlgRec(Graph *G, VerticesGroup *group, LinkedList *groupsLst, doubl
         modularityAfterMax = maximizeModularity(G, group, s, modularity);
     } while (modularityAfterMax > modularity);
 
-    if (!IS_POSITIVE(modularity)) {
-        insertItem(groupsLst, group);
+    if (!IS_POSITIVE(modularityAfterMax)) {
         return;
     }
 
-    divideGroupByEigenvector(group, s, &newGroupA, &newGroupB);
-    if (newGroupA == NULL || newGroupB == NULL) {
-        insertItem(groupsLst, group);
-    } else {
-        divisionAlgRec(G, newGroupA, groupsLst, vector, s);
-        divisionAlgRec(G, newGroupB, groupsLst, vector, s);
-    }
+    divideGroupByEigenvector(group, s, newGroupA, newGroupB);
 }
 
 /**
@@ -168,8 +158,10 @@ void divisionAlgRec(Graph *G, VerticesGroup *group, LinkedList *groupsLst, doubl
 LinkedList *divisionAlgorithm(Graph *G) {
     int i;
     double *vector, *s;
-    LinkedList *groupsLst = createLinkedList();
-    VerticesGroup *group;
+    LinkedList *P, *O;
+    VerticesGroup *group, *groupA, *groupB;
+    P = createLinkedList();
+    O = createLinkedList();
 
     /* Notice that the formula for the expected number of edges
      * between two given vertices requires division by zero if
@@ -181,9 +173,9 @@ LinkedList *divisionAlgorithm(Graph *G) {
         for (i = 0; i < G->n; ++i) {
             group = createVerticesGroup();
             addVertexToGroup(group, i);
-            insertItem(groupsLst, group);
+            insertItem(P, group);
         }
-        return groupsLst;
+        return P;
     }
 
     vector = malloc(G->n * sizeof(double));
@@ -194,10 +186,32 @@ LinkedList *divisionAlgorithm(Graph *G) {
     for (i = 0; i < G->n; i++) {
         addVertexToGroup(group, i);
     }
-    divisionAlgRec(G, group, groupsLst, vector, s);
+    insertItem(P, group);
+    while (P->first != NULL) {
+        groupA = NULL;
+        groupB = NULL;
+        group = P->first->pointer;
+        removeItem(P, P->first);
+        divisionAlgorithm2(G, group, vector, s, &groupA, &groupB);
+        if (groupA == NULL || groupB == NULL) {
+            insertItem(O, group);
+        } else {
+            if (groupA->size == 1) {
+                insertItem(O, groupA);
+            } else {
+                insertItem(P, groupA);
+            }
+            if (groupB->size == 1) {
+                insertItem(O, groupB);
+            } else {
+                insertItem(P, groupB);
+            }
+        }
+    }
+
     free(vector);
     free(s);
-    return groupsLst;
+    return O;
 }
 
 void saveOutputToFile(LinkedList *groupLst, char *output_path) {

division.h

@@ -14,7 +14,8 @@ void divideGroupByEigenvector(VerticesGroup *group, double *s, VerticesGroup **s
 
 double maximizeModularity(Graph *G, VerticesGroup *group, double *s, double initialModularity);
 
-void divisionAlgRec(Graph *G, VerticesGroup *group, LinkedList *groupsLst, double *vector, double *s);
+void divisionAlgorithm2(Graph *G, VerticesGroup *group, double *vector, double *s, VerticesGroup **newGroupA,
+                             VerticesGroup **newGroupB);
 
 void saveOutputToFile(LinkedList *groupLst, char *output_path);
 

tests/neoTests/main.c

@@ -21,11 +21,8 @@
 
 #include <stdlib.h>
 #include <stdio.h>
-#include <string.h>
 #include "../../cluster.h"
 
-#define DIR "C:\\Users\\royar\\Source\\Workspaces\\Workspace\\C projects\\cproject-cluster\\tests\\neoTests\\"
-
 /**
 void printA(int* a, int size){
     int i;
@@ -215,48 +212,48 @@ int main() {
 
     argv[0] = "name";
 
-    argv[1] = DIR"3empty";
-    argv[2] = DIR"3emptyOut";
+    argv[1] = "3empty";
+    argv[2] = "3emptyOut";
     cluster(argc, argv);
 
-    argv[1] = DIR"30empty";
-    argv[2] = DIR"30emptyOut";
+    argv[1] = "30empty";
+    argv[2] = "30emptyOut";
     cluster(argc, argv);
 
-    argv[1] = DIR"3c";
-    argv[2] = DIR"3cOut";
+    argv[1] = "3c";
+    argv[2] = "3cOut";
     cluster(argc, argv);
 
-    argv[1] = DIR"30c";
-    argv[2] = DIR"30cOut";
+    argv[1] = "30c";
+    argv[2] = "30cOut";
     cluster(argc, argv);
 
-    argv[1] = DIR"30a";
-    argv[2] = DIR"30aOut";
+    argv[1] = "30a";
+    argv[2] = "30aOut";
     cluster(argc, argv);
 
-    argv[1] = DIR"300c";
-    argv[2] = DIR"300cOut";
+    argv[1] = "300c";
+    argv[2] = "300cOut";
     cluster(argc, argv);
 
-    argv[1] = DIR"300a";
-    argv[2] = DIR"300aOut";
+    argv[1] = "300a";
+    argv[2] = "300aOut";
     cluster(argc, argv);
 
-    argv[1] = DIR"20-30c";
-    argv[2] = DIR"20-30cOut";
+    argv[1] = "20-30c";
+    argv[2] = "20-30cOut";
     cluster(argc, argv);
 
-    argv[1] = DIR"20-30a";
-    argv[2] = DIR"20-30aOut";
+    argv[1] = "20-30a";
+    argv[2] = "20-30aOut";
     cluster(argc, argv);
 
-    argv[1] = DIR"60-100c";
-    argv[2] = DIR"60-100cOut";
+    argv[1] = "60-100c";
+    argv[2] = "60-100cOut";
     cluster(argc, argv);
 
-    argv[1] = DIR"60-100a";
-    argv[2] = DIR"60-100aOut";
+    argv[1] = "60-100a";
+    argv[2] = "60-100aOut";
     cluster(argc, argv);
 
 

tests/tester.c

@@ -5,8 +5,7 @@
 #include <time.h>
 #include <stdio.h>
 
-#define GRAPHS_DIR "C:\\Users\\royar\\Source\\Workspaces\\Workspace\\C projects\\cproject-cluster\\tests\\graphs"
-/*#define GRAPHS_DIR "D:\\Users\\idodo\\OneDrive - mail.tau.ac.il\\Studies\\Tel Aviv University\\Semester 4\\Software Project\\Homework\\Project\\Project\\tests\\graphs"*/
+#define GRAPHS_DIR "tests\\graphs"
 
 void printColorings(int *coloring1, int *coloring2, int n);