Ajout de dequeue et bollarray avec leurs tests
This commit is contained in:
376
Anna et Ethan/shell_test.c
Normal file
376
Anna et Ethan/shell_test.c
Normal file
@@ -0,0 +1,376 @@
|
||||
#include "shell_test.h"
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include "files.h"
|
||||
#include "graphs.h"
|
||||
#include "nfa.h"
|
||||
#include "nfa_determi.h"
|
||||
#include "nfa_tocode.h"
|
||||
#include "parse_regexp.h"
|
||||
#include "parser.h"
|
||||
#include "shell_languages.h"
|
||||
#include "shell_tools.h"
|
||||
#include "type_boolarray.h"
|
||||
#include "type_dequeue.h"
|
||||
|
||||
// Cette fonction est appelée par le shell sur la commande "test".
|
||||
// Vous pouvez y mettre le code que vous voulez tester.
|
||||
|
||||
#define TEST_DEQUEUE true
|
||||
#define TEST_BOOLARRAY false
|
||||
#define NB_TESTS_OCCUR 1000
|
||||
|
||||
static void printf_dequeue(dequeue *dq, char *function, char *var,
|
||||
int i_function, int i_result) {
|
||||
if (function != NULL)
|
||||
printf("%s(", function);
|
||||
else
|
||||
printf("%s\n", var);
|
||||
if (function != NULL && i_function >= 0) printf("%d, ", i_function);
|
||||
if (function != NULL) printf("%s)", var);
|
||||
if (function != NULL && i_result >= 0)
|
||||
printf(" = %d\n", i_result);
|
||||
else if (function != NULL)
|
||||
printf("\n");
|
||||
print_dequeue(dq);
|
||||
printf("isempty_dequeue(%s) = %d\n", var, isempty_dequeue(dq));
|
||||
printf("size_dequeue(%s) = %d\n", var, size_dequeue(dq));
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
static void printf_boolarray(barray *ba, char *function, char *var,
|
||||
int i_function, int i_result) {
|
||||
if (function != NULL)
|
||||
printf("%s(", function);
|
||||
else
|
||||
printf("%s\n", var);
|
||||
if (function != NULL && i_function >= 0) printf("%d, ", i_function);
|
||||
if (function != NULL) printf("%s)", var);
|
||||
if (function != NULL && i_result >= 0)
|
||||
printf(" = %d\n", i_result);
|
||||
else if (function != NULL)
|
||||
printf("\n");
|
||||
printf("Boolarray : ");
|
||||
for (uint i = 0; i < getsize_barray(ba); i++) {
|
||||
printf("%d ", getval_barray(ba, i));
|
||||
}
|
||||
printf("\n");
|
||||
printf("getsize_barray(%s) = %d\n", var, getsize_barray(ba));
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
void test(void) {
|
||||
// regexp *myexp;
|
||||
|
||||
// Cette première affectation ne fonctionnera que si vous avez implémenté
|
||||
// les fonctions du module regexp.h.
|
||||
// myexp = parse_string_regexp("(a+bb)*");
|
||||
|
||||
// L'affichage de l'expression régulière est fait par la fonction reg_print,
|
||||
// définie dans printing.c et déjà fournie. Vous pouvez la décommenter pour
|
||||
// afficher l'expression régulière, après avoir implémenté les fonctions
|
||||
// nécessaires dans regexp.c.
|
||||
// reg_print(myexp);
|
||||
|
||||
// Autre exemple, avec une construction directe de NFA.
|
||||
// nfa* A = create_sing_epsilon();
|
||||
// nfa_view(A);
|
||||
|
||||
// Tests de dequeue
|
||||
if (TEST_DEQUEUE) {
|
||||
dequeue *dq = create_dequeue();
|
||||
printf_dequeue(dq, NULL, "dq", 0, -1);
|
||||
for (uint i = 11; i <= 20; i++) {
|
||||
rigins_dequeue(i, dq);
|
||||
// printf_dequeue(dq, "rigins_dequeue", "dq", i, -1);
|
||||
}
|
||||
for (uint i = 10; i > 0; i--) {
|
||||
lefins_dequeue(i, dq);
|
||||
// printf_dequeue(dq, "leftins_dequeue", "dq", i, -1);
|
||||
}
|
||||
printf("--------------------\n");
|
||||
printf(
|
||||
"Test rigins_dequeue et leftins_dequeue\n"); // Test rigins_dequeue
|
||||
// et leftins_dequeue
|
||||
printf("--------------------\n");
|
||||
for (uint i = 0; i < size_dequeue(dq); i++) {
|
||||
assert(lefread_dequeue(dq, i) == i + 1);
|
||||
printf("assert(lefread_dequeue(dq, %d) == %d) check\n", i, i + 1);
|
||||
}
|
||||
for (uint i = 0; i < 20; i++) {
|
||||
if (i % 2 == 0) {
|
||||
uint tmp[i / 2];
|
||||
for (uint j = 0; j < i / 2; j++) {
|
||||
// printf_dequeue(dq, "lefread_dequeue", "dq", -1,
|
||||
// lefread_dequeue(dq, 0));
|
||||
tmp[j] = lefpull_dequeue(dq);
|
||||
// printf_dequeue(dq, "lefpull_dequeue",
|
||||
// "dq", -1, -1);
|
||||
}
|
||||
for (uint j = 0; j < i / 2; j++) {
|
||||
lefins_dequeue(tmp[i / 2 - j - 1], dq);
|
||||
// printf_dequeue(dq, "lefins_dequeue", "dq", tmp[j], -1);
|
||||
}
|
||||
} else {
|
||||
uint tmp[i / 2];
|
||||
for (uint j = 0; j < i / 2; j++) {
|
||||
// printf_dequeue(dq, "rigread_dequeue", "dq", -1,
|
||||
// rigread_dequeue(dq, 0));
|
||||
tmp[j] = rigpull_dequeue(dq);
|
||||
// printf_dequeue(dq, "rigpull_dequeue", "dq", -1, -1);
|
||||
}
|
||||
for (uint j = 0; j < i / 2; j++) {
|
||||
rigins_dequeue(tmp[i / 2 - j - 1], dq);
|
||||
// printf_dequeue(dq, "rigins_dequeue", "dq", tmp[j], -1);
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("--------------------\n");
|
||||
printf(
|
||||
"Test lefpull_dequeue et rigpull_dequeue\n"); // Test
|
||||
// lefpull_dequeue et
|
||||
// rigpull_dequeue
|
||||
printf("--------------------\n");
|
||||
for (uint i = 0; i < size_dequeue(dq); i++) {
|
||||
assert(lefread_dequeue(dq, i) == i + 1);
|
||||
printf("assert(lefread_dequeue(dq, %d) == %d) check\n", i, i + 1);
|
||||
}
|
||||
printf("--------------------\n");
|
||||
printf(
|
||||
"Test makeempty_dequeue et copy_dequeue_right in array [1, 20]\n"); // Test makeempty_dequeue et copy_dequeue_right
|
||||
printf("--------------------\n");
|
||||
dequeue *dq2 = create_dequeue();
|
||||
for (uint i = 0; i < 10; i++) {
|
||||
makeempty_dequeue(dq2);
|
||||
// printf_dequeue(dq2, "makeempty_dequeue", "dq2", -1, -1);
|
||||
copy_dequeue_right(dq2, dq, i);
|
||||
// printf_dequeue(dq2, "copy_dequeue_right", "dq2", i, -1);
|
||||
printf("----------");
|
||||
printf(" Test +%d ", i);
|
||||
printf("----------\n");
|
||||
for (uint j = 0; j < size_dequeue(dq2); j++) {
|
||||
assert(lefread_dequeue(dq2, j) == lefread_dequeue(dq, j) + i);
|
||||
printf("assert(lefread_dequeue(dq2, %d) == %d) check\n", j,
|
||||
lefread_dequeue(dq, j) + i);
|
||||
}
|
||||
}
|
||||
printf("--------------------\n");
|
||||
printf("Test mem_dequeue in array [1, 20]\n"); // Test mem_dequeue
|
||||
printf("--------------------\n");
|
||||
for (uint i = 0; i < 20; i++) {
|
||||
uint value = rand() % 100;
|
||||
// printf_dequeue(dq, "mem_dequeue", "dq2", value,
|
||||
// mem_dequeue(value, dq));
|
||||
assert(mem_dequeue(value, dq) == (value > 0 && value <= 20));
|
||||
printf("assert(mem_dequeue(%d, dq) == %d) check\n", value,
|
||||
(value > 0 && value <= 20));
|
||||
}
|
||||
if (dq == NULL) delete_dequeue(dq2);
|
||||
for (uint k = 0; k < NB_TESTS_OCCUR; k++) {
|
||||
dq2 = create_dequeue();
|
||||
for (uint i = 0; i < 20; i++) {
|
||||
lefins_dequeue(rand() % 100, dq2);
|
||||
}
|
||||
// printf_dequeue(dq2, "random", "dq2", -1, -1);
|
||||
sort_dequeue_norepeat(dq2);
|
||||
// printf_dequeue(dq2, "sort_dequeue_norepeat", "dq2", -1, -1);
|
||||
printf("--------------------\n");
|
||||
printf(
|
||||
"Test sort_dequeue_norepeat\n"); // Test sort_dequeue_norepeat
|
||||
printf("--------------------\n");
|
||||
for (uint i = 0; i < size_dequeue(dq2) - 1; i++) {
|
||||
assert(lefread_dequeue(dq2, i) < lefread_dequeue(dq2, i + 1));
|
||||
printf(
|
||||
"%u - assert(lefread_dequeue(dq2, %d) < "
|
||||
"lefread_dequeue(dq2, "
|
||||
"%d)) "
|
||||
"check\n",
|
||||
k, i, i + 1);
|
||||
}
|
||||
// for (uint i = 0; i < 20; i++) {
|
||||
// printf_dequeue(dq2, "mem_dequeue_sorted", "dq2", i,
|
||||
// mem_dequeue_sorted(i, dq2));
|
||||
// }
|
||||
printf("--------------------\n");
|
||||
printf("Test mem_dequeue_sorted\n"); // Test mem_dequeue_sorted
|
||||
printf("--------------------\n");
|
||||
for (uint i = 0; i < 20; i++) {
|
||||
assert(mem_dequeue_sorted(i, dq2) == mem_dequeue(i, dq2));
|
||||
printf("assert(mem_dequeue_sorted(%d, dq2) == %d) check\n", i,
|
||||
mem_dequeue(i, dq2));
|
||||
}
|
||||
if (dq2 == NULL) delete_dequeue(dq2);
|
||||
}
|
||||
printf("--------------------\n");
|
||||
printf("Test merge_sorted_dequeue\n"); // Test merge_sorted_dequeue
|
||||
printf("--------------------\n");
|
||||
for (uint k = 0; k < NB_TESTS_OCCUR; k++) {
|
||||
dq = create_dequeue();
|
||||
dq2 = create_dequeue();
|
||||
dequeue *dq3 = create_dequeue();
|
||||
for (uint i = 0; i < 10; i++) {
|
||||
lefins_dequeue(rand() % 100, dq);
|
||||
lefins_dequeue(rand() % 100, dq2);
|
||||
}
|
||||
sort_dequeue_norepeat(dq);
|
||||
sort_dequeue_norepeat(dq2);
|
||||
copy_dequeue_right(dq3, dq, 0);
|
||||
merge_sorted_dequeue(dq3, dq2);
|
||||
for (uint i = 0; i < size_dequeue(dq3) - 1; i++) {
|
||||
assert(lefread_dequeue(dq3, i) < lefread_dequeue(dq3, i + 1));
|
||||
printf(
|
||||
"%u - assert(lefread_dequeue(dq2, %d) < "
|
||||
"lefread_dequeue(dq2, "
|
||||
"%d)) "
|
||||
"check\n",
|
||||
k, i, i + 1);
|
||||
}
|
||||
for (uint i = 0; i < size_dequeue(dq3); i++) {
|
||||
assert(mem_dequeue_sorted(lefread_dequeue(dq3, i), dq) ||
|
||||
mem_dequeue_sorted(lefread_dequeue(dq3, i), dq2));
|
||||
printf(
|
||||
"%u - assert(mem_dequeue_sorted(%d, dq) || "
|
||||
"mem_dequeue_sorted(%d, dq2)) check\n",
|
||||
k, lefread_dequeue(dq3, i), lefread_dequeue(dq3, i));
|
||||
}
|
||||
for (uint i = 0; i < size_dequeue(dq); i++) {
|
||||
assert(mem_dequeue_sorted(lefread_dequeue(dq, i), dq3));
|
||||
printf(
|
||||
"%u - assert(mem_dequeue_sorted(leftread_dequeue(dq, %d), "
|
||||
"dq3)) check\n",
|
||||
k, i);
|
||||
}
|
||||
for (uint i = 0; i < size_dequeue(dq2); i++) {
|
||||
assert(mem_dequeue_sorted(lefread_dequeue(dq2, i), dq3));
|
||||
printf(
|
||||
"%u - assert(mem_dequeue_sorted(leftread_dequeue(dq2, %d), "
|
||||
"dq3)) check\n",
|
||||
k, i);
|
||||
}
|
||||
if (dq == NULL) delete_dequeue(dq);
|
||||
if (dq2 == NULL) delete_dequeue(dq2);
|
||||
if (dq3 == NULL) delete_dequeue(dq3);
|
||||
}
|
||||
printf("--------------------\n");
|
||||
printf(
|
||||
"Test make_inter_sorted_dequeue\n"); // Test
|
||||
// make_inter_sorted_dequeue
|
||||
printf("--------------------\n");
|
||||
for (uint k = 0; k < NB_TESTS_OCCUR; k++) {
|
||||
dq = create_dequeue();
|
||||
dq2 = create_dequeue();
|
||||
for (uint i = 0; i < 20; i++) {
|
||||
lefins_dequeue(rand() % 100, dq);
|
||||
lefins_dequeue(rand() % 100, dq2);
|
||||
}
|
||||
sort_dequeue_norepeat(dq);
|
||||
sort_dequeue_norepeat(dq2);
|
||||
dequeue *dq3 = make_inter_sorted_dequeue(dq, dq2);
|
||||
for (uint i = 0; i < size_dequeue(dq3); i++) {
|
||||
assert(mem_dequeue_sorted(lefread_dequeue(dq3, i), dq) &&
|
||||
mem_dequeue_sorted(lefread_dequeue(dq3, i), dq2));
|
||||
printf(
|
||||
"%u - assert(mem_dequeue_sorted(%d, dq) && "
|
||||
"mem_dequeue_sorted(%d, dq2)) check\n",
|
||||
k, lefread_dequeue(dq3, i), lefread_dequeue(dq3, i));
|
||||
}
|
||||
if (dq == NULL) delete_dequeue(dq);
|
||||
if (dq2 == NULL) delete_dequeue(dq2);
|
||||
if (dq3 == NULL) delete_dequeue(dq3);
|
||||
}
|
||||
printf("--------------------\n");
|
||||
printf("Test intersec_dequeue\n"); // Test
|
||||
// intersec_dequeue
|
||||
printf("--------------------\n");
|
||||
for (uint k = 0; k < NB_TESTS_OCCUR; k++) {
|
||||
dq = create_dequeue();
|
||||
dq2 = create_dequeue();
|
||||
for (uint i = 0; i < 10; i++) {
|
||||
lefins_dequeue(rand() % 100, dq);
|
||||
lefins_dequeue(rand() % 100, dq2);
|
||||
}
|
||||
sort_dequeue_norepeat(dq);
|
||||
sort_dequeue_norepeat(dq2);
|
||||
bool result = intersec_dequeue(dq, dq2);
|
||||
dequeue *dq3 = make_inter_sorted_dequeue(dq, dq2);
|
||||
assert(result == (size_dequeue(dq3) > 0));
|
||||
printf(
|
||||
"%u - size_dequeue(make_inter_sorted_dequeue(dq, dq2)) check\n",
|
||||
k);
|
||||
if (dq == NULL) delete_dequeue(dq);
|
||||
if (dq2 == NULL) delete_dequeue(dq2);
|
||||
}
|
||||
for (uint k = 0; k < NB_TESTS_OCCUR; k++) {
|
||||
dq = create_dequeue();
|
||||
for (uint i = 0; i < 10; i++) {
|
||||
lefins_dequeue(rand() % 100, dq);
|
||||
}
|
||||
sort_dequeue_norepeat(dq);
|
||||
uint val = rand() % 100;
|
||||
insert_dequeue(dq, val);
|
||||
for (uint i = 0; i < size_dequeue(dq) - 1; i++) {
|
||||
assert(lefread_dequeue(dq, i) < lefread_dequeue(dq, i + 1));
|
||||
printf(
|
||||
"%u - assert(lefread_dequeue(dq2, %d) < "
|
||||
"lefread_dequeue(dq2, "
|
||||
"%d)) "
|
||||
"check\n",
|
||||
k, i, i + 1);
|
||||
}
|
||||
assert(mem_dequeue_sorted(val, dq));
|
||||
printf("%u - assert(mem_dequeue_sorted(%d, dq)) check\n", k, val);
|
||||
if (dq == NULL) delete_dequeue(dq);
|
||||
}
|
||||
printf("--------------------\n");
|
||||
printf("Plus de %d tests effectués avec succès\n", NB_TESTS_OCCUR * 5);
|
||||
}
|
||||
// Tests de boolarray
|
||||
if (TEST_BOOLARRAY) {
|
||||
barray *ba = create_barray(10);
|
||||
printf_boolarray(ba, NULL, "ba", 0, -1);
|
||||
for (uint i = 0; i < 10; i++) {
|
||||
if (i % 2 == 0) {
|
||||
settrue_barray(ba, i);
|
||||
printf_boolarray(ba, "settrue_barray", "ba", i, -1);
|
||||
} else {
|
||||
setfalse_barray(ba, i);
|
||||
printf_boolarray(ba, "setfalse_barray", "ba", i, -1);
|
||||
}
|
||||
}
|
||||
delete_barray(ba);
|
||||
ba = create_barray(10);
|
||||
for (uint i = 0; i < 10; i++) {
|
||||
bool x = rand() % 2;
|
||||
if (x) {
|
||||
settrue_barray(ba, i);
|
||||
printf_boolarray(ba, "settrue_barray", "ba", i, -1);
|
||||
} else {
|
||||
setfalse_barray(ba, i);
|
||||
printf_boolarray(ba, "setfalse_barray", "ba", i, -1);
|
||||
}
|
||||
}
|
||||
barray *ba2 = create_barray(10);
|
||||
for (uint i = 0; i < 10; i++) {
|
||||
bool x = rand() % 2;
|
||||
if (x) {
|
||||
settrue_barray(ba2, i);
|
||||
} else {
|
||||
setfalse_barray(ba2, i);
|
||||
}
|
||||
}
|
||||
printf_boolarray(ba2, NULL, "ba2", -1, -1);
|
||||
barray *ba3 = or_barray(ba, ba2);
|
||||
printf_boolarray(ba3, "or_barray", "ba3", -1, -1);
|
||||
delete_barray(ba3);
|
||||
ba3 = and_barray(ba, ba2);
|
||||
printf_boolarray(ba3, "and_barray", "ba3", -1, -1);
|
||||
delete_barray(ba3);
|
||||
delete_barray(ba2);
|
||||
printf_boolarray(ba, NULL, "ba", -1, -1);
|
||||
ba2 = copy_barray(ba);
|
||||
printf_boolarray(ba2, "copy_barray", "ba", -1, -1);
|
||||
delete_barray(ba);
|
||||
}
|
||||
}
|
||||
112
Anna et Ethan/type_boolarray.c
Normal file
112
Anna et Ethan/type_boolarray.c
Normal file
@@ -0,0 +1,112 @@
|
||||
#include "type_boolarray.h"
|
||||
|
||||
barray *create_barray(uint size) {
|
||||
barray *ptr = malloc(sizeof(barray));
|
||||
ptr->size = size;
|
||||
if (size % 8 == 0) {
|
||||
ptr->size_array = size / 8;
|
||||
} else {
|
||||
ptr->size_array = size / 8 + 1;
|
||||
}
|
||||
ptr->array = malloc(ptr->size_array * sizeof(uchar));
|
||||
for (uint i = 0; i < ptr->size_array; i++) {
|
||||
ptr->array[i] = false;
|
||||
}
|
||||
|
||||
return ptr;
|
||||
}
|
||||
|
||||
uint getsize_barray(barray *ptr) {
|
||||
if (ptr == NULL) {
|
||||
ERROR("getsize_barray: ptr is NULL");
|
||||
}
|
||||
return ptr->size;
|
||||
}
|
||||
|
||||
void delete_barray(barray *ptr) {
|
||||
if (ptr == NULL) {
|
||||
return;
|
||||
}
|
||||
if (ptr->array != NULL) {
|
||||
free(ptr->array);
|
||||
}
|
||||
free(ptr);
|
||||
return;
|
||||
}
|
||||
|
||||
void settrue_barray(barray *ptr, uint num_bool) {
|
||||
if (ptr == NULL) {
|
||||
ERROR("settrue_barray: ptr is NULL");
|
||||
}
|
||||
if (num_bool >= ptr->size) {
|
||||
ERROR("settrue_barray: cell is out of bounds");
|
||||
}
|
||||
uint cell = num_bool / 8;
|
||||
uint bit = num_bool % 8;
|
||||
ptr->array[cell] |= 1 << bit;
|
||||
return;
|
||||
}
|
||||
|
||||
void setfalse_barray(barray *ptr, uint num_bool) {
|
||||
if (ptr == NULL) {
|
||||
ERROR("setfalse_barray: ptr is NULL");
|
||||
}
|
||||
if (num_bool >= ptr->size) {
|
||||
ERROR("setfalse_barray: cell is out of bounds");
|
||||
}
|
||||
uint cell = num_bool / 8;
|
||||
uint bit = num_bool % 8;
|
||||
ptr->array[cell] &= ~(1 << bit);
|
||||
return;
|
||||
}
|
||||
|
||||
bool getval_barray(barray *ptr, uint num_bool) {
|
||||
if (ptr == NULL) {
|
||||
ERROR("getval_barray: ptr is NULL");
|
||||
}
|
||||
if (num_bool >= ptr->size) {
|
||||
ERROR("getval_barray: cell is out of bounds");
|
||||
}
|
||||
uint cell = num_bool / 8;
|
||||
uint bit = num_bool % 8;
|
||||
return (ptr->array[cell] & 1 << bit);
|
||||
}
|
||||
|
||||
barray *or_barray(barray *ptr1, barray *ptr2) {
|
||||
if (ptr1 == NULL || ptr2 == NULL) {
|
||||
ERROR("or_barray: ptr is NULL");
|
||||
}
|
||||
if (ptr1->size != ptr2->size) {
|
||||
return NULL;
|
||||
}
|
||||
barray *ptr = create_barray(ptr1->size);
|
||||
for (uint i = 0; i < ptr->size; i++) {
|
||||
ptr->array[i] = ptr1->array[i] | ptr2->array[i];
|
||||
}
|
||||
return ptr;
|
||||
}
|
||||
|
||||
barray *and_barray(barray *ptr1, barray *ptr2) {
|
||||
if (ptr1 == NULL || ptr2 == NULL) {
|
||||
ERROR("or_barray: ptr is NULL");
|
||||
}
|
||||
if (ptr1->size != ptr2->size) {
|
||||
return NULL;
|
||||
}
|
||||
barray *ptr = create_barray(ptr1->size);
|
||||
for (uint i = 0; i < ptr->size; i++) {
|
||||
ptr->array[i] = ptr1->array[i] & ptr2->array[i];
|
||||
}
|
||||
return ptr;
|
||||
}
|
||||
|
||||
barray *copy_barray(barray *ptr) {
|
||||
if (ptr == NULL) {
|
||||
ERROR("copy_barray: ptr is NULL");
|
||||
}
|
||||
barray *copy = create_barray(ptr->size);
|
||||
for (uint i = 0; i < ptr->size_array; i++) {
|
||||
copy->array[i] = ptr->array[i];
|
||||
}
|
||||
return copy;
|
||||
}
|
||||
332
Anna et Ethan/type_dequeue.c
Normal file
332
Anna et Ethan/type_dequeue.c
Normal file
@@ -0,0 +1,332 @@
|
||||
/*****************************************/
|
||||
/* Implémentations des listes de sommets */
|
||||
/* Utilisation d'un tuyau par liste */
|
||||
/*****************************************/
|
||||
|
||||
#include "type_dequeue.h"
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "error.h"
|
||||
#include "type_boolarray.h"
|
||||
|
||||
/************************/
|
||||
/* Fonctions primitives */
|
||||
/************************/
|
||||
|
||||
/* Création */
|
||||
dequeue *create_dequeue(void) {
|
||||
dequeue *ptr = malloc(sizeof(dequeue));
|
||||
ptr->array = malloc(sizeof(uint) * 1);
|
||||
ptr->size_array = 1;
|
||||
ptr->left = 0;
|
||||
ptr->right = 0;
|
||||
ptr->empty = true;
|
||||
return ptr;
|
||||
}
|
||||
|
||||
/* Suppression */
|
||||
void delete_dequeue(dequeue *ptr) {
|
||||
if (ptr == NULL) ERROR("delete_dequeue : ptr NULL");
|
||||
if (ptr->array != NULL) free(ptr->array);
|
||||
if (ptr != NULL) free(ptr);
|
||||
ptr = NULL;
|
||||
}
|
||||
|
||||
/* Test du vide */
|
||||
bool isempty_dequeue(dequeue *ptr) {
|
||||
if (ptr == NULL) ERROR("isempty_dequeue : ptr NULL");
|
||||
return ptr->empty;
|
||||
}
|
||||
|
||||
/* Vidage d'un tuyau*/
|
||||
void makeempty_dequeue(dequeue *ptr) {
|
||||
if (ptr == NULL) ERROR("makeempty_dequeue : ptr NULL");
|
||||
if (ptr->array != NULL) free(ptr->array);
|
||||
ptr->array = malloc(sizeof(uint) * 1);
|
||||
ptr->size_array = 1;
|
||||
ptr->left = 0;
|
||||
ptr->right = 0;
|
||||
ptr->empty = true;
|
||||
}
|
||||
|
||||
/* Taille */
|
||||
uint size_dequeue(dequeue *ptr) {
|
||||
if (ptr == NULL) ERROR("size_dequeue : ptr NULL");
|
||||
if (isempty_dequeue(ptr))
|
||||
return 0;
|
||||
else if (ptr->right > ptr->left)
|
||||
return ptr->right - ptr->left;
|
||||
else if (ptr->right == ptr->left)
|
||||
return ptr->size_array;
|
||||
else
|
||||
return ptr->size_array - ptr->left + ptr->right;
|
||||
}
|
||||
|
||||
/* Lecture */
|
||||
uint lefread_dequeue(dequeue *ptr, uint i) {
|
||||
if (ptr == NULL) ERROR("lefread_dequeue : ptr NULL");
|
||||
if (isempty_dequeue(ptr)) ERROR("lefread_dequeue : ptr empty");
|
||||
if (i >= size_dequeue(ptr)) ERROR("lefread_dequeue : i out of bounds");
|
||||
return ptr->array[(ptr->left + i) % ptr->size_array];
|
||||
}
|
||||
|
||||
uint rigread_dequeue(dequeue *ptr, uint i) {
|
||||
if (ptr == NULL) ERROR("rigread_dequeue : ptr NULL");
|
||||
if (isempty_dequeue(ptr)) ERROR("rigread_dequeue : ptr empty");
|
||||
if (i >= size_dequeue(ptr)) ERROR("rigread_dequeue : i out of bounds");
|
||||
return ptr->array[(ptr->right - i - 1) % ptr->size_array];
|
||||
}
|
||||
|
||||
static void grow_dequeue(dequeue *ptr) {
|
||||
if (ptr == NULL) ERROR("grow_dequeue : ptr NULL");
|
||||
while (ptr->left != 0) {
|
||||
int temp = ptr->array[ptr->left];
|
||||
for (uint i = 0; i < ptr->size_array; i++) {
|
||||
ptr->array[(ptr->left + i) % ptr->size_array] =
|
||||
ptr->array[(ptr->left + i + 1) % ptr->size_array];
|
||||
}
|
||||
ptr->array[(ptr->left - 1) % ptr->size_array] = temp;
|
||||
ptr->left--;
|
||||
ptr->right = (ptr->right - 1) % ptr->size_array;
|
||||
}
|
||||
ptr->right = ptr->size_array;
|
||||
ptr->left = 0;
|
||||
ptr->size_array *= 2;
|
||||
ptr->array = realloc(ptr->array, ptr->size_array * sizeof(int));
|
||||
return;
|
||||
}
|
||||
|
||||
/* Insérer */
|
||||
void lefins_dequeue(uint val, dequeue *ptr) {
|
||||
if (ptr == NULL) ERROR("lefins_dequeue : ptr NULL");
|
||||
if (ptr->left == ptr->right && !isempty_dequeue(ptr)) {
|
||||
grow_dequeue(ptr);
|
||||
}
|
||||
ptr->left = (ptr->left - 1 + ptr->size_array) % ptr->size_array;
|
||||
ptr->array[ptr->left] = val;
|
||||
ptr->empty = false;
|
||||
return;
|
||||
}
|
||||
|
||||
void rigins_dequeue(uint val, dequeue *ptr) {
|
||||
if (ptr == NULL) ERROR("rigins_dequeue : ptr NULL");
|
||||
if (ptr->left == ptr->right && !isempty_dequeue(ptr)) {
|
||||
grow_dequeue(ptr);
|
||||
}
|
||||
ptr->array[ptr->right] = val;
|
||||
ptr->right = (ptr->right + 1) % ptr->size_array;
|
||||
ptr->empty = false;
|
||||
return;
|
||||
}
|
||||
|
||||
static void shrink_dequeue(dequeue *ptr) {
|
||||
if (ptr == NULL) ERROR("shrink_dequeue : ptr NULL");
|
||||
uint *aux = malloc((ptr->size_array / 2) * sizeof(uint));
|
||||
for (uint i = 0; i < size_dequeue(ptr); i++) {
|
||||
aux[i] = ptr->array[(ptr->left + i) % ptr->size_array];
|
||||
}
|
||||
free(ptr->array);
|
||||
ptr->array = aux;
|
||||
ptr->left = 0;
|
||||
ptr->size_array = ptr->size_array / 2;
|
||||
ptr->right = size_dequeue(ptr);
|
||||
return;
|
||||
}
|
||||
|
||||
/* Retirer */
|
||||
uint lefpull_dequeue(dequeue *ptr) {
|
||||
if (ptr == NULL) ERROR("lefpull_dequeue : ptr NULL");
|
||||
if (isempty_dequeue(ptr)) ERROR("lefpull_dequeue : ptr empty");
|
||||
int val = ptr->array[ptr->left];
|
||||
ptr->left = (ptr->left + 1) % ptr->size_array;
|
||||
if (size_dequeue(ptr) <= ptr->size_array / 4 && ptr->size_array > 1) {
|
||||
shrink_dequeue(ptr);
|
||||
}
|
||||
if (ptr->left == ptr->right) ptr->empty = true;
|
||||
return val;
|
||||
}
|
||||
|
||||
uint rigpull_dequeue(dequeue *ptr) {
|
||||
if (ptr == NULL) ERROR("rigpull_dequeue : ptr NULL");
|
||||
if (isempty_dequeue(ptr)) ERROR("rigpull_dequeue : ptr empty");
|
||||
ptr->right = (ptr->right - 1) % ptr->size_array;
|
||||
int val = ptr->array[ptr->right];
|
||||
if (size_dequeue(ptr) <= ptr->size_array / 4 && ptr->size_array > 1) {
|
||||
shrink_dequeue(ptr);
|
||||
}
|
||||
if (ptr->left == ptr->right) ptr->empty = true;
|
||||
return val;
|
||||
}
|
||||
|
||||
/* Création d'une copie avec décalage */
|
||||
void copy_dequeue_right(dequeue *ptr1, dequeue *ptr2, uint val) {
|
||||
if (ptr1 == NULL || ptr2 == NULL) ERROR("copy_dequeue_right : ptr NULL");
|
||||
if (isempty_dequeue(ptr2)) ERROR("copy_dequeue_right : ptr2 empty");
|
||||
for (uint i = 0; i < size_dequeue(ptr2); i++) {
|
||||
lefread_dequeue(ptr2, i);
|
||||
rigins_dequeue(lefread_dequeue(ptr2, i) + val, ptr1);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/* Teste si un élément appartient à une dequeue*/
|
||||
bool mem_dequeue(uint val, dequeue *ptr) {
|
||||
if (ptr == NULL) ERROR("mem_dequeue : ptr NULL");
|
||||
for (uint i = 0; i < size_dequeue(ptr); i++) {
|
||||
if (val == lefread_dequeue(ptr, i)) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Affichage */
|
||||
void print_dequeue(dequeue *ptr) {
|
||||
if (ptr == NULL) ERROR("print_dequeue : ptr NULL");
|
||||
printf("Deque : ");
|
||||
for (uint i = 0; i < size_dequeue(ptr); i++) {
|
||||
printf("%d ", lefread_dequeue(ptr, i));
|
||||
}
|
||||
printf("\n");
|
||||
return;
|
||||
}
|
||||
|
||||
/* Tri par ordre croissant et suppression des doublons */
|
||||
void sort_dequeue_norepeat(dequeue *ptr) {
|
||||
if (ptr == NULL) ERROR("sort_dequeue_norepeat : ptr NULL");
|
||||
if (isempty_dequeue(ptr)) return;
|
||||
if (size_dequeue(ptr) == 1) return;
|
||||
for (uint i = 0; i < size_dequeue(ptr); i++) {
|
||||
for (uint j = i + 1; j < size_dequeue(ptr); j++) {
|
||||
if (lefread_dequeue(ptr, i) > lefread_dequeue(ptr, j)) {
|
||||
int temp = lefread_dequeue(ptr, i);
|
||||
ptr->array[(ptr->left + i) % ptr->size_array] =
|
||||
lefread_dequeue(ptr, j);
|
||||
ptr->array[(ptr->left + j) % ptr->size_array] = temp;
|
||||
}
|
||||
}
|
||||
}
|
||||
uint i;
|
||||
for (i = 0; i < size_dequeue(ptr) &&
|
||||
lefread_dequeue(ptr, i) != rigread_dequeue(ptr, 0);
|
||||
i++) {
|
||||
uint count = 0;
|
||||
while (i + count < size_dequeue(ptr) &&
|
||||
lefread_dequeue(ptr, i) == lefread_dequeue(ptr, i + count)) {
|
||||
count++;
|
||||
}
|
||||
for (uint j = 1; j < count; j++) {
|
||||
for (uint k = i; k < size_dequeue(ptr) - 1; k++) {
|
||||
ptr->array[(ptr->left + k) % ptr->size_array] =
|
||||
lefread_dequeue(ptr, k + 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
ptr->right = (ptr->right - (size_dequeue(ptr) - i - 1)) % ptr->size_array;
|
||||
return;
|
||||
}
|
||||
|
||||
/*****************************************************************/
|
||||
/* Fonctions spécifiques aux ensembles triés par ordre croissant */
|
||||
/*****************************************************************/
|
||||
|
||||
bool mem_dequeue_sorted(uint val, dequeue *ptr) {
|
||||
if (ptr == NULL) ERROR("mem_dequeue_sorted : ptr NULL");
|
||||
if (isempty_dequeue(ptr)) return false;
|
||||
int left = 0;
|
||||
int right = size_dequeue(ptr) - 1;
|
||||
while (left <= right) {
|
||||
int mid = (left + right) / 2;
|
||||
if (lefread_dequeue(ptr, mid) == val) return true;
|
||||
if (lefread_dequeue(ptr, mid) < val) {
|
||||
left = mid + 1;
|
||||
} else {
|
||||
right = mid - 1;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void merge_sorted_dequeue(dequeue *ptr1, dequeue *ptr2) {
|
||||
if (ptr1 == NULL || ptr2 == NULL) ERROR("merge_sorted_dequeue : ptr NULL");
|
||||
if (isempty_dequeue(ptr2)) return;
|
||||
if (isempty_dequeue(ptr1)) {
|
||||
copy_dequeue_right(ptr1, ptr2, 0);
|
||||
return;
|
||||
}
|
||||
uint i = 0;
|
||||
uint j = 0;
|
||||
dequeue *temp = create_dequeue();
|
||||
while (i < size_dequeue(ptr1) && j < size_dequeue(ptr2)) {
|
||||
if (lefread_dequeue(ptr1, i) <= lefread_dequeue(ptr2, j)) {
|
||||
rigins_dequeue(lefread_dequeue(ptr1, i), temp);
|
||||
i++;
|
||||
} else {
|
||||
rigins_dequeue(lefread_dequeue(ptr2, j), temp);
|
||||
j++;
|
||||
}
|
||||
}
|
||||
while (i < size_dequeue(ptr1)) {
|
||||
rigins_dequeue(lefread_dequeue(ptr1, i), temp);
|
||||
i++;
|
||||
}
|
||||
while (j < size_dequeue(ptr2)) {
|
||||
rigins_dequeue(lefread_dequeue(ptr2, j), temp);
|
||||
j++;
|
||||
}
|
||||
makeempty_dequeue(ptr1);
|
||||
copy_dequeue_right(ptr1, temp, 0);
|
||||
if (temp == NULL) delete_dequeue(temp);
|
||||
for (i = 0; i < size_dequeue(ptr1) &&
|
||||
lefread_dequeue(ptr1, i) != rigread_dequeue(ptr1, 0);
|
||||
i++) {
|
||||
uint count = 0;
|
||||
while (i + count < size_dequeue(ptr1) &&
|
||||
lefread_dequeue(ptr1, i) == lefread_dequeue(ptr1, i + count)) {
|
||||
count++;
|
||||
}
|
||||
for (j = 1; j < count; j++) {
|
||||
for (uint k = i; k < size_dequeue(ptr1) - 1; k++) {
|
||||
ptr1->array[(ptr1->left + k) % ptr1->size_array] =
|
||||
lefread_dequeue(ptr1, k + 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
ptr1->right =
|
||||
(ptr1->right - (size_dequeue(ptr1) - i - 1)) % ptr1->size_array;
|
||||
return;
|
||||
}
|
||||
|
||||
dequeue *make_inter_sorted_dequeue(dequeue *ptr1, dequeue *ptr2) {
|
||||
if (ptr1 == NULL || ptr2 == NULL)
|
||||
ERROR("make_inter_sorted_dequeue : ptr NULL");
|
||||
dequeue *ptr = create_dequeue();
|
||||
for (uint i = 0; i < size_dequeue(ptr1); i++) {
|
||||
if (mem_dequeue_sorted(lefread_dequeue(ptr1, i), ptr2)) {
|
||||
rigins_dequeue(lefread_dequeue(ptr1, i), ptr);
|
||||
}
|
||||
}
|
||||
return ptr;
|
||||
}
|
||||
|
||||
/* Insére un nouveau sommet dans une liste */
|
||||
void insert_dequeue(dequeue *ptr, uint val) {
|
||||
if (ptr == NULL) ERROR("insert_dequeue : ptr NULL");
|
||||
if (mem_dequeue_sorted(val, ptr)) return;
|
||||
dequeue *temp = create_dequeue();
|
||||
rigins_dequeue(val, temp);
|
||||
merge_sorted_dequeue(ptr, temp);
|
||||
}
|
||||
|
||||
/* Teste si deux dequeues triées s'intersectent */
|
||||
bool intersec_dequeue(dequeue *ptr1, dequeue *ptr2) {
|
||||
if (ptr1 == NULL || ptr2 == NULL) ERROR("intersec_dequeue : ptr NULL");
|
||||
if (isempty_dequeue(ptr1) || isempty_dequeue(ptr2)) return false;
|
||||
for (uint i = 0; i < size_dequeue(ptr1); i++) {
|
||||
if (mem_dequeue_sorted(lefread_dequeue(ptr1, i), ptr2)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
Reference in New Issue
Block a user