Algorithme et implémentation de recherche de coque convexe en langage C
Le problème de la coque convexe est un problème important en géométrie computationnelle, qui décrit le plus petit polygone convexe dans un ensemble de points. Dans cet article, nous explorerons l'algorithme et son implémentation en utilisant le langage C pour résoudre le problème de la coque convexe.
Algorithme et implémentation de recherche de coque convexe en langage C
La clé de l’algorithme de coque convexe est de savoir comment déterminer si un point se trouve sur la coque convexe. Pour un ensemble de points donné, nous pouvons choisir un point comme point de départ et y connecter d’autres points dans un certain ordre. Si les lignes de connexion d’un point se trouvent à l’intérieur des limites de l’enveloppe convexe, alors le point se trouve sur l’enveloppe convexe. Sur la base de cette idée, nous pouvons concevoir l’algorithme suivant pour résoudre le problème de la coque convexe.
-
Trouvez le point P0 le plus à gauche dans le point défini comme point de départ.
-
Triez les autres points du jeu de points en fonction de leur angle polaire avec P0.
-
Reliez les points triés afin de former un polygone convexe.
-
Parcourez la ligne de connexion et déterminez si chaque point se trouve dans la limite de l'enveloppe convexe.
-
Si tous les points se trouvent dans les limites de l’enveloppe convexe, l’algorithme se termine ; sinon, le point le plus éloigné est supprimé de l’enveloppe convexe et revient à l’étape 4.
Voici un exemple de code implémenté en langage C :
#inclure
// Définir une structure de points
structure typedef {
entier x ;
int y;
} Indiquer;
// Calcule le carré de la distance entre deux points
int distance (Point p1, Point p2) {
int dx = p1.x - p2.x;
int dy = p1.y - p2.y;
retourner dx * dx + dy * dy;
}
// Détermine si le point p est dans la limite de l'enveloppe convexe
int inConvexHull(Point p, Point coque[], int taille) {
// Traverse les limites de la coque convexe
pour (int i = 0; i < taille - 1; i++) {
Point p1 = coque[i] ;
Point p2 = coque[i + 1] ;
// Calculer la distance depuis la limite de la coque convexe
int d1 = (p1.x - px) * (p2.y - py) - (p1.y - py) * (p2.x - px);
int d2 = distance(p1, p2);
// Si la distance est inférieure à 0, le point est en dehors de la limite de l'enveloppe convexe
si (d1 < 0) {
renvoie 0 ;
}
// Si la distance est égale à 0, cela signifie que le point est sur la limite de l'enveloppe convexe
si ( d1 == 0 & & d2 >= distance ( p1 , p )) {
renvoie 0 ;
}
}
renvoyer 1 ;
}
// Algorithme pour trouver une coque convexe
void convexHull(Point points[], int n) {
// Trouver le point le plus à gauche P0
int le plus à gauche = 0 ;
pour (int je = 1; je < n; i++) {
si (points[i].x < points[le plus à gauche].x) {
le plus à gauche = je;
}
}
// Trier les autres points par angle polaire
// L'implémentation spécifique de l'algorithme de tri est omise ici.
// Relie les points pour former un polygone convexe
nombre entier = 0 ;
Coque de pointe[n] ;
coque[count++] = points[le plus à gauche];
int suivant ;
faire {
suivant = (le plus à gauche + 1) % n ;
pour (int je = 0; je < n; i++) {
if (i != le plus à gauche && i != next && inConvexHull(points[i], hull, count)) {
suivant = je;
}
}
coque[count++] = points[suivant];
le plus à gauche = suivant ;
} while (le plus à gauche != 0);
// Sortie des points de la coque convexe
pour (int je = 0; je < nombre; i++) {
printf(\d, %d) \ coque[i].x, coque[i].y);
}
printf(\n}
int main() {
// Supposons que nous ayons l'ensemble de points suivant
Points de points[] = { {0, 3}, {1, 1}, {2, 2}, {4, 4},
{0, 0}, {1, 2}, {3, 1}, {3, 3}} ;
int n = taille de (points) / taille de (points [0]);
// Appel de l'algorithme de coque convexe
convexHull(points, n);
renvoie 0 ;
}
Grâce à l'algorithme et à l'implémentation ci-dessus, nous pouvons trouver l'enveloppe convexe d'un ensemble de points donné. La complexité temporelle de cet algorithme est O(n^2), où n est la taille de l'ensemble de points. La clé de l'algorithme est de déterminer si un point se trouve à l'intérieur des limites de l'enveloppe convexe. Cette détermination peut être réalisée efficacement grâce au calcul et à la comparaison des distances.
Pour résumer, l'algorithme et la mise en œuvre de la recherche de l'enveloppe convexe en langage C sont basés sur la connexion et le jugement de position des points. En sélectionnant le point de départ, en triant par angle polaire, en reliant les points et en jugeant si le point se trouve dans la limite de l'enveloppe convexe, nous pouvons obtenir l'enveloppe convexe de l'ensemble de points. Cet algorithme a de nombreuses applications dans la géométrie computationnelle et le traitement graphique. J'espère que l'explication contenue dans cet article sera utile aux lecteurs.
Une partie du code est transférée depuis : https://www.ktiao.com/c/2023-08/254131.html