TP3 fini

tp3/TP3/main.c

@@ -8,10 +8,10 @@
 #include <time.h>
 
 // Basculez à 1 les valeurs ci-dessous pour activer les tests correspondants.
-#define TEST_STACK_BASIC 1
+#define TEST_STACK_BASIC 0
 #define TEST_SORT_STACK  0
-#define TEST_COPY_STACK  1
-#define TEST_HANOI       1
+#define TEST_COPY_STACK  0
+#define TEST_HANOI       0
 
 #define TEST_QUEUE_BASIC 0
 #define TEST_COPY_QUEUE  0

tp3/TP3/queue.c

@@ -1,5 +1,6 @@
 #include "queue.h"
 #include "alloc.h"
+#include "testprint.h"
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -14,14 +15,40 @@
 // Cette fonction sera utilisée lorsque le tableau est plein et qu'on veut y
 // ajouter une valeur.
 static void grow_queue(queue *p) {
-  return;
+    while (p -> left != 0) {
+        int temp = p -> array[p -> left];
+        for (int j = 0; j < p -> size_array; j++) {
+            p -> array[(p -> left + j) % p -> size_array] = p -> array[(p -> left + j + 1) % p -> size_array];
+        }
+        p -> array[(p -> left - 1) % p -> size_array] = temp;
+        p -> left--;
+        p -> right = (p -> right - 1) % p -> size_array;
+    }
+    p -> right = p -> size_array;
+    p -> left = 0;
+    p -> size_array *= 2;
+    p -> array = realloc(p -> array, p -> size_array * sizeof(int));
+    return;
 }
 
 // Divise par deux la taille du tableau utilisé dans la représentation
 // Cette fonction sera utilisée lorsque le tableau est rempli à moins de 25% de
 // sa capacité.
 static void shrink_queue(queue *p) {
-  return;
+    if (p -> size_array >= 2) {
+        while (p -> left != 0) {
+            int temp = p -> array[p -> left];
+            for (int j = 0; j < p -> size_array; j++) {
+                p -> array[(p -> left + j) % p -> size_array] = p -> array[(p -> left + j + 1) % p -> size_array];
+            }
+            p -> array[(p -> left - 1) % p -> size_array] = temp;
+            p -> left--;
+            p -> right = (p -> right - 1) % p -> size_array;
+        }
+        p -> size_array /= 2;
+        p -> array = realloc(p -> array, p -> size_array * sizeof(int));
+    }
+    return;
 }
 
 ////////////////////////////////////////////////////////////////
@@ -29,25 +56,72 @@ static void shrink_queue(queue *p) {
 ////////////////////////////////////////////////////////////////
 
 queue *create_queue(void) {
-  return NULL;
+    queue *p = malloc(sizeof(queue));
+    p -> size_array = 1;
+    p -> left = 0;
+    p -> right = 0;
+    p -> array = malloc(sizeof(int));
+    p -> empty = true;
+    return p;
 }
 
 void delete_queue(queue *p) {
-  return;
+    if (p == NULL) return;
+    p -> size_array = 0;
+    p -> left = 0;
+    p -> right = 0;
+    p -> empty = true;
+    free(p -> array);
+    free(p);
+    return;
 }
 
 bool isempty_queue(const queue *p) {
-  return false;
+    return p -> empty;
 }
 
 int getsize_queue(const queue *p) {
-  return 0;
+    if (isempty_queue(p)) return 0;
+    else if (p -> right > p -> left) return p -> right - p -> left;
+    else if (p -> right == p -> left) return p -> size_array;
+    else return p -> size_array - (p -> left - p -> right);
 }
 
 void enqueue(int val, queue *p) {
-  return;
+    if (p -> left == p -> right && !isempty_queue(p)) {
+        grow_queue(p);
+    }
+    p -> left--;
+    if (p -> left < 0) {
+        p -> left += p -> size_array;
+    }
+    p -> array[p -> left] = val;
+    p -> empty = false;
+    return;
 }
 
 int dequeue(queue *p) {
-  return 0;
+    // print_queue(p);
+    if (isempty_queue(p)) {
+        FATAL("Pop on empty queue");
+    }
+    p -> right--;
+    if (p -> right < 0) {
+        p -> right += p -> size_array;
+    }
+    int val = p -> array[p -> right];
+    if (getsize_queue(p) <= p -> size_array / 4 && p -> size_array > 1) {
+        shrink_queue(p);
+    } else if (getsize_queue(p) <= p -> size_array / 4) {
+        p -> empty = true;
+        val = p -> array[p -> left];
+        p -> left = 0;
+        p -> right = 0;
+        return val;
+    }
+    // printf("left = %d, right = %d size = %d\n", p -> left, p -> right, getsize_queue(p));
+    if (p -> left == p -> right + 1) {
+        p -> empty = true;
+    }
+    return val;
 }

tp3/TP3/queue.d

@@ -1 +1 @@
-queue.o: queue.c queue.h alloc.h error.h
+queue.o: queue.c queue.h alloc.h error.h testprint.h stack.h

tp3/TP3/queuetest.c

@@ -1,21 +1,59 @@
 #include "queuetest.h"
 #include "alloc.h"
+#include "queue.h"
+#include "testprint.h"
 #include <stdbool.h>
-#include <stdio.h>
 #include <stdlib.h>
 
 queue *random_queue(int size, int maxval) {
-  return NULL;
+    queue* p = create_queue();
+    for (int i = 0; i < size; i++) {
+        enqueue(rand() % maxval, p);
+        // print_queue(p);
+    }
+    return p;
 }
 
 queue *copy_queue(queue *p) {
-  return NULL;
+    queue* p_out = create_queue();
+    for (int i = 0; i < getsize_queue(p); i++) {
+        // printf("left: %d right: %d size: %d\n", p -> left, p -> right, p -> size_array);
+        int val = dequeue(p);
+        // printf("val: %d\n", val);
+        enqueue(val, p);
+        enqueue(val, p_out);
+        // print_queue(p);
+        // print_queue(p_out);
+    }
+    return p_out;
 }
 
 queue *mountain_queue(int n) {
-  return NULL;
+    queue* p = create_queue();
+    for (int i = 0; i < n; i++) {
+        enqueue(n - i, p);
+        // print_queue(p);
+    }
+    return p;
 }
 
 void select_sort_queue(queue *p) {
-  return;
+    int n = getsize_queue(p);
+    for (int i = 0; i < n; i++) {
+        int max = dequeue(p);
+        for (int j = 1; j < n - i; j++) {
+            int val = dequeue(p);
+            if (val > max) {
+                enqueue(max, p);
+                max = val;
+            } else {
+                enqueue(val, p);
+            }
+        }
+        for (int j = 0; j < i; j++) {
+            enqueue(dequeue(p), p);
+        }
+        enqueue(max, p);
+    }
+    return;
 }

tp3/TP3/queuetest.d

@@ -1 +1,2 @@
-queuetest.o: queuetest.c queuetest.h queue.h alloc.h error.h
+queuetest.o: queuetest.c queuetest.h queue.h alloc.h error.h testprint.h \
+ stack.h

tp3/TP3/stack.h

@@ -1,5 +1,4 @@
 /***********************************************/
-/***********************************************/
 /** Implémentation des piles par les tableaux **/
 /***********************************************/
 /***********************************************/

tp3/TP3/stacktest.c

@@ -64,5 +64,29 @@ void hanoi_rec(stack *p1, stack *p2, stack *p3,
 }
 
 void bubble_sort_stack(stack *p) {
+    int n = size_stack(p);
+    stack *p_aux = create_stack();
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < n - 1; j++) {
+            push(pop(p), p_aux);
+        }
+        print_stacks(n - i, 2, p, p_aux);
+        for (int j = i; j < n - 1; j++) {
+            int a = pop(p);
+            int b = pop(p_aux);
+            if (a < b) {
+                push(a, p);
+                push(b, p);
+            } else {
+                push(b, p);
+                push(a, p);
+            }
+        }
+        for (int j = 0; j < i; j++) {
+            push(pop(p_aux), p);
+        }
+        printf("\n");
+    }
+    delete_stack(p_aux);
     return;
 }