backup/C-Plus-Plus
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/C-Plus-Plus.git synced 2026-02-10 05:57:14 +08:00
Code Issues Projects Releases Wiki Activity

clang-format and clang-tidy fixes for e89e4c8c

Browse Source
This commit is contained in:
github-actions
2021-11-06 06:48:57 +00:00
parent c88a858ea2
commit af702116fd
4 changed files with 260 additions and 253 deletions
Download Patch File Download Diff File Expand all files Collapse all files

99
geometry/graham_scan_algorithm.cpp
View File

@@ -1,61 +1,58 @@
/******************************************************************************
* @file
* @brief Implementation of the [Convex Hull](https://en.wikipedia.org/wiki/Convex_hull)
* implementation using [Graham Scan](https://en.wikipedia.org/wiki/Graham_scan)
* @details
* In geometry, the convex hull or convex envelope or convex closure of a shape
* is the smallest convex set that contains it. The convex hull may be defined
* either as the intersection of all convex sets containing a given subset of a
* Euclidean space, or equivalently as the set of all convex combinations of
* points in the subset. For a bounded subset of the plane, the convex hull may
* be visualized as the shape enclosed by a rubber band stretched around the subset.
*
* The worst case time complexity of Jarvis’s Algorithm is O(n^2). Using Graham’s
* scan algorithm, we can find Convex Hull in O(nLogn) time.
*
* ### Implementation
*
* Sort points
* We first find the bottom-most point. The idea is to pre-process
* points be sorting them with respect to the bottom-most point. Once the points
* are sorted, they form a simple closed path.
* The sorting criteria is to use the orientation to compare angles without actually
* computing them (See the compare() function below) because computation of actual
* angles would be inefficient since trigonometric functions are not simple to evaluate.
*
* Accept or Reject Points
* Once we have the closed path, the next step is to traverse the path and
* remove concave points on this path using orientation. The first two points in
* sorted array are always part of Convex Hull. For remaining points, we keep track
* of recent three points, and find the angle formed by them. Let the three points
* be prev(p), curr(c) and next(n). If orientation of these points (considering them
* in same order) is not counterclockwise, we discard c, otherwise we keep it.
*
* @author [Lajat Manekar](https://github.com/Lazeeez)
*
*******************************************************************************/
#include <iostream> /// for IO Operations
#include <cassert> /// for std::assert
#include <vector> /// for std::vector
#include "./graham_scan_functions.hpp" /// for all the functions used
* @file
* @brief Implementation of the [Convex
*Hull](https://en.wikipedia.org/wiki/Convex_hull) implementation using [Graham
*Scan](https://en.wikipedia.org/wiki/Graham_scan)
* @details
* In geometry, the convex hull or convex envelope or convex closure of a shape
* is the smallest convex set that contains it. The convex hull may be defined
* either as the intersection of all convex sets containing a given subset of a
* Euclidean space, or equivalently as the set of all convex combinations of
* points in the subset. For a bounded subset of the plane, the convex hull may
* be visualized as the shape enclosed by a rubber band stretched around the
*subset.
*
* The worst case time complexity of Jarvis’s Algorithm is O(n^2). Using
*Graham’s scan algorithm, we can find Convex Hull in O(nLogn) time.
*
* ### Implementation
*
* Sort points
* We first find the bottom-most point. The idea is to pre-process
* points be sorting them with respect to the bottom-most point. Once the points
* are sorted, they form a simple closed path.
* The sorting criteria is to use the orientation to compare angles without
*actually computing them (See the compare() function below) because computation
*of actual angles would be inefficient since trigonometric functions are not
*simple to evaluate.
*
* Accept or Reject Points
* Once we have the closed path, the next step is to traverse the path and
* remove concave points on this path using orientation. The first two points in
* sorted array are always part of Convex Hull. For remaining points, we keep
*track of recent three points, and find the angle formed by them. Let the three
*points be prev(p), curr(c) and next(n). If orientation of these points
*(considering them in same order) is not counterclockwise, we discard c,
*otherwise we keep it.
*
* @author [Lajat Manekar](https://github.com/Lazeeez)
*
*******************************************************************************/
#include <cassert> /// for std::assert
#include <iostream> /// for IO Operations
#include <vector> /// for std::vector
#include "./graham_scan_functions.hpp" /// for all the functions used
/*******************************************************************************
* @brief Self-test implementations
* @returns void
*******************************************************************************/
static void test() {
std::vector<geometry::grahamscan::Point> points = {{0, 3},
{1, 1},
{2, 2},
{4, 4},
{0, 0},
{1, 2},
{3, 1},
{3, 3}};
std::vector<geometry::grahamscan::Point> expected_result = {{0, 3},
{4, 4},
{3, 1},
{0, 0}};
std::vector<geometry::grahamscan::Point> points = {
{0, 3}, {1, 1}, {2, 2}, {4, 4}, {0, 0}, {1, 2}, {3, 1}, {3, 3}};
std::vector<geometry::grahamscan::Point> expected_result = {
{0, 3}, {4, 4}, {3, 1}, {0, 0}};
std::vector<geometry::grahamscan::Point> derived_result;
std::vector<geometry::grahamscan::Point> res;