ajout de nos fichiers
This commit is contained in:
Aloyse ARNAUD
386
Anna et Vincent/type_dequeue.c
Normal file
386
Anna et Vincent/type_dequeue.c
Normal file
@@ -0,0 +1,386 @@
|
||||
|
||||
/*****************************************/
|
||||
/* 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))
|
||||
return;
|
||||
for (uint i = 0; i < size_dequeue(ptr2); i++) {
|
||||
lefread_dequeue(ptr2, i);
|
||||
rigins_dequeue(lefread_dequeue(ptr2, i) + val, ptr1);
|
||||
}
|
||||
return;
|
||||
}
|
||||
*/
|
||||
|
||||
/* 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)) {
|
||||
return;
|
||||
}
|
||||
for (uint i = 0; i < size_dequeue(ptr2); i++) {
|
||||
lefread_dequeue(ptr2, i);
|
||||
rigins_dequeue(lefread_dequeue(ptr2, i) + val, ptr1);
|
||||
}
|
||||
}
|
||||
|
||||
/* 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