update comments

Author: codejsha

cpp-algorithm/src/array/advancing_through.h

@@ -5,9 +5,11 @@
 
 namespace AdvancingThrough
 {
-    /// @brief Advance through the array to the last index.
-    /// @param max_advance_steps maximum number of steps that can be taken from each index
-    /// @return either reach the end or not
+    /**
+     * \brief Advance through the array to the last index.
+     * \param max_advance_steps maximum number of steps that can be taken from each index
+     * \return either reach the end or not
+     */
     auto CanReachEnd(const std::vector<int>& max_advance_steps) -> bool;
 }
 

cpp-algorithm/src/array/delete_element.h

@@ -5,20 +5,26 @@
 
 namespace DeleteElement
 {
-    /// @brief Delete duplicate elements in the array.
-    /// @param numbers input array
-    /// @return result array
+    /**
+     * \brief Delete duplicate elements in the array.
+     * \param numbers input array
+     * \return result array
+     */
     auto DeleteDuplicates(std::vector<int>& numbers) -> std::vector<int>;
 
-    /// @brief Delete duplicate elements in the array.
-    /// @param numbers input array
-    /// @return result array
+    /**
+     * \brief Delete duplicate elements in the array.
+     * \param numbers input array
+     * \return result array
+     */
     auto DeleteDuplicateElements(std::vector<int>& numbers) -> std::vector<int>;
 
-    /// @brief Delete specific elements in the array.
-    /// @param numbers input array
-    /// @param element specific element
-    /// @return result array
+    /**
+     * \brief Delete specific elements in the array.
+     * \param numbers input array
+     * \param element specific element
+     * \return result array
+     */
     auto DeleteSpecificElements(std::vector<int>& numbers, int element) -> std::vector<int>;
 }
 

cpp-algorithm/src/array/dutch_national_flag.h

@@ -5,30 +5,38 @@
 
 namespace DutchFlag
 {
-    /// @brief Color enum
+    /**
+     * \brief Color enum
+     */
     enum Color
     {
         Red,
         White,
         Blue
     };
 
-    /// @brief Dutch national flag problem.
-    /// @param pivot_index pivot index
-    /// @param arr input array
-    /// @return result array
+    /**
+     * \brief Dutch national flag problem.
+     * \param pivot_index pivot index
+     * \param arr input array
+     * \return result array
+     */
     auto DutchFlagPartition1(int pivot_index, std::vector<Color>& arr) -> std::vector<Color>;
 
-    /// @brief Dutch national flag problem.
-    /// @param pivot_index pivot index
-    /// @param arr input array
-    /// @return result array
+    /**
+     * \brief Dutch national flag problem.
+     * \param pivot_index pivot index
+     * \param arr input array
+     * \return result array
+     */
     auto DutchFlagPartition2(int pivot_index, std::vector<Color>& arr) -> std::vector<Color>;
 
-    /// @brief Dutch national flag problem.
-    /// @param pivot_index pivot index
-    /// @param arr input array
-    /// @return result array
+    /**
+     * \brief Dutch national flag problem.
+     * \param pivot_index pivot index
+     * \param arr input array
+     * \return result array
+     */
     auto DutchFlagPartition3(int pivot_index, std::vector<Color>& arr) -> std::vector<Color>;
 }
 

cpp-algorithm/src/array/enumerate_prime_number.h

@@ -5,9 +5,11 @@
 
 namespace EnumeratePrime
 {
-    /// @brief Enumerate prime numbers in the range.
-    /// @param n upper bound
-    /// @return prime numbers
+    /**
+     * brief Enumerate prime numbers in the range.
+     * param n upper bound
+     * return prime numbers
+     */
     auto GeneratePrimes(int n) -> std::vector<int>;
 }
 

cpp-algorithm/src/array/order_element.h

@@ -5,14 +5,18 @@
 
 namespace OrderElement
 {
-    /// @brief Order even and odd numbers in the array.
-    /// @param arr numbers
+    /**
+     * \brief Order even and odd numbers in the array.
+     * \param arr numbers
+     */
     void EvenOdd(std::vector<int>& arr);
 
-    /// @brief Rearrange arrays to have a specific order.
-    /// A[0] <= A[1] >= A[2] <= A[3] >= A[4] <= A[5] >= ...
-    /// @param numbers input array
-    /// @return ordered array
+    /**
+     * \brief Rearrange arrays to have a specific order.
+     * A[0] <= A[1] >= A[2] <= A[3] >= A[4] <= A[5] >= ...
+     * \param numbers input array
+     * \return ordered array
+     */
     auto Rearrange(std::vector<int>& numbers) -> std::vector<int>;
 }
 

cpp-algorithm/src/array/random_data_sampling.h

@@ -5,24 +5,30 @@
 
 namespace RandomDataSampling
 {
-    /// @brief Randomly select k elements from the array.
-    /// @param k sample size
-    /// @param arr input array
-    /// @return result array
+    /**
+     * \brief Randomly select k elements from the array.
+     * \param k sample size
+     * \param arr input array
+     * \return result array
+     */
     auto OfflineRandomSampling(int k, std::vector<int>& arr) -> std::vector<int>;
 
-    // TODO: OnlineRandomSampling
-    /// @brief Randomly select k elements from the array.
-    /// @param begin begin iterator
-    /// @param end end iterator
-    /// @param k sample size
-    /// @return result array
+    // TODO: Implement OnlineRandomSampling
+    /**
+     * \brief Randomly select k elements from the array.
+     * \param begin begin iterator
+     * \param end end iterator
+     * \param k sample size
+     * \return result array
+     */
     auto OnlineRandomSampling(const std::vector<int>::const_iterator& begin,
                               const std::vector<int>::const_iterator& end, int k) -> std::vector<int>;
 
-    /// @brief Compute permutation of the array generated by random sampling.
-    /// @param n sample size
-    /// @return result array
+    /**
+     * \brief Compute permutation of the array generated by random sampling.
+     * \param n sample size
+     * \return result array
+     */
     auto ComputeRandomPermutation(int n) -> std::vector<int>;
 }
 

cpp-algorithm/src/array/replace_element.h

@@ -6,27 +6,33 @@
 
 namespace ReplaceElement
 {
-    /// @brief Replace element and remove element in the array. Keep the array size.
-    /// @param arr input array
-    /// @param replace_str replace string
-    /// @param remove_str remove string
-    /// @return result array
+    /**
+     * \brief Replace element and remove element in the array. Keep the array size.
+     * \param arr input array
+     * \param replace_str replace string
+     * \param remove_str remove string
+     * \return result array
+     */
     auto ReplaceAndRemoveString1(std::vector<std::string>& arr, const std::string& replace_str,
                                  const std::string& remove_str) -> std::vector<std::string>;
 
-    /// @brief Replace element and remove element in the array.
-    /// Use some STL algorithms.
-    /// @param arr input array
-    /// @param replace_str replace string
-    /// @param remove_str remove string
-    /// @return result array
+    /**
+     * \brief Replace element and remove element in the array.
+     * Use some STL algorithms.
+     * \param arr input array
+     * \param replace_str replace string
+     * \param remove_str remove string
+     * \return result array
+     */
     auto ReplaceAndRemoveString2(std::vector<std::string>& arr, const std::string& replace_str,
                                  const std::string& remove_str) -> std::vector<std::string>;
 
-    /// @brief Telex encoding for punctuation marks.
-    /// Replace '.' with 'DOT', ',' with 'COMMA', '?' with 'QUESTION_MARK', '!' with 'EXCLAMATION_MARK'.
-    /// @param arr input array (possibly contains punctuation marks)
-    /// @return result array
+    /**
+     * \brief Telex encoding for punctuation marks.
+     * Replace '.' with 'DOT', ',' with 'COMMA', '?' with 'QUESTION_MARK', '!' with 'EXCLAMATION_MARK'.
+     * \param arr input array (possibly contains punctuation marks)
+     * \return result array
+     */
     auto TelexEncoding(std::vector<std::string>& arr) -> std::vector<std::string>;
 }
 

cpp-algorithm/src/dynamic_programming/longest_common_subsequence.h

@@ -7,26 +7,32 @@
 
 namespace CommonSubsequence
 {
-    /// @brief Compute the length of an LCS of two sequences
-    /// @param seq1 string sequence 1
-    /// @param seq2 string sequence 2
-    /// @return length and direction matrices
+    /**
+     * \brief Compute the length of an LCS of two sequences
+     * \param seq1 string sequence 1
+     * \param seq2 string sequence 2
+     * \return length and direction matrices
+     */
     auto LongestCommonSubsequenceLength(const std::string& seq1, const std::string& seq2)
         -> std::tuple<gsl_matrix_int*, gsl_matrix_char*>;
 
-    /// @brief Constructing an LCS from the length matrix
-    /// @param seq1 string sequence 1
-    /// @param direction_matrix direction matrix
-    /// @param length1 length of the string sequence 1
-    /// @param length2 length of the string sequence 2
-    /// @param result LCS string
+    /**
+     * \brief Constructing an LCS from the length matrix
+     * \param seq1 string sequence 1
+     * \param direction_matrix direction matrix
+     * \param length1 length of the string sequence 1
+     * \param length2 length of the string sequence 2
+     * \param result LCS string
+     */
     void LongestCommonSubsequence(const std::string& seq1, const gsl_matrix_char* direction_matrix, int length1,
                                   int length2, std::string& result);
 
-    /// @brief Print table of LCS lengths
-    /// @param seq1 string sequence 1
-    /// @param seq2 string sequence 2
-    /// @param direction_matrix direction matrix
+    /**
+     * \brief Print table of LCS lengths
+     * \param seq1 string sequence 1
+     * \param seq2 string sequence 2
+     * \param direction_matrix direction matrix
+     */
     void PrintOptimalMatrix(const std::string& seq1, const std::string& seq2, const gsl_matrix_char* direction_matrix);
 }
 

cpp-algorithm/src/dynamic_programming/rod_cutting.h

@@ -6,37 +6,47 @@
 
 namespace RodCutting
 {
-    /// @brief Rod cutting algorithm to call recursively.
-    /// @param price prices for rod length
-    /// @param length length of a rod
-    /// @return the maximum revenue
+    /**
+     * \brief Rod cutting algorithm to call recursively.
+     * \param price prices for rod length
+     * \param length length of a rod
+     * \return the maximum revenue
+     */
     auto CutRod(const std::map<int, int>& price, int length) -> int;
 
-    /// @brief Rod cutting algorithm with memoization that use top-down approach.
-    /// @param price prices for rod length
-    /// @param length length of a rod
-    /// @return the maximum revenue
+    /**
+     * \brief Rod cutting algorithm with memoization that use top-down approach.
+     * \param price prices for rod length
+     * \param length length of a rod
+     * \return the maximum revenue
+     */
     auto MemoizedCutRod(const std::map<int, int>& price, int length) -> int;
 
-    /// @brief Sub procedure for rod cutting algorithm with memoization.
-    /// This use auxiliary array for memoization.
-    /// @param price prices for rod length
-    /// @param length length of a rod
-    /// @param memo memoized results
-    /// @return the maximum revenue
+    /**
+     * \brief Sub procedure for rod cutting algorithm with memoization.
+     * This use auxiliary array for memoization.
+     * \param price prices for rod length
+     * \param length length of a rod
+     * \param memo memoized results
+     * \return the maximum revenue
+     */
     auto MemoizedCutRodAux(const std::map<int, int>& price, int length, std::vector<int>& memo) -> int;
 
-    /// @brief Rod cutting algorithm that use bottom-up approach.
-    /// @param price prices for rod length
-    /// @param length length of a rod
-    /// @return the maximum revenue
+    /**
+     * \brief Rod cutting algorithm that use bottom-up approach.
+     * \param price prices for rod length
+     * \param length length of a rod
+     * \return the maximum revenue
+     */
     auto BottomUpCutRod(const std::map<int, int>& price, int length) -> int;
 
-    /// @brief Rod cutting algorithm that computes the maximum revenue and the optimal size of the first piece for given
-    /// rod length.
-    /// @param price prices for rod length
-    /// @param length length of a rod
-    /// @return the maximum revenue and the optimal size of the first piece
+    /**
+     * \brief Rod cutting algorithm that computes the maximum revenue and the optimal size of the first piece for given
+     * rod length.
+     * \param price prices for rod length
+     * \param length length of a rod
+     * \return the maximum revenue and the optimal size of the first piece
+     */
     auto ExtendedBottomUpCutRod(const std::map<int, int>& price, int length) -> std::tuple<int, int>;
 }
 

cpp-algorithm/src/graph/bellman_ford.h

@@ -26,10 +26,12 @@ namespace BellmanFord
         void AddVertex(Vertex& v);
         void AddEdge(Vertex& u, Vertex& v, int weight);
 
-        /// @brief Bellman-Ford algorithm. Find the shortest path from a source vertex to all other vertices.
-        /// @details A single source shortest path algorithm that can handle negative edge weights.
-        /// It finds the shortest path from a source vertex to all other vertices in a weighted graph.
-        /// @param source source vertex
+        /**
+         * \brief Bellman-Ford algorithm. Find the shortest path from a source vertex to all other vertices.
+         * \details A single source shortest path algorithm that can handle negative edge weights.
+         * It finds the shortest path from a source vertex to all other vertices in a weighted graph.
+         * \param source source vertex
+         */
         void BellmanFordAlgorithm(Vertex& source);
 
         std::vector<Vertex*> vertices;

cpp-algorithm/src/graph/breadth_first_search.h

@@ -30,11 +30,13 @@ namespace Bfs
     class Graph
     {
     public:
-        /// @brief Breadth first search algorithm.
-        /// @details A search algorithm that traverses a graph layer by layer.
-        /// @param start starting vertex
-        /// @param goal goal vertex
-        /// @return goal vertex
+        /**
+         * \brief Breadth first search algorithm.
+         * \details A search algorithm that traverses a graph layer by layer.
+         * \param start starting vertex
+         * \param goal goal vertex
+         * \return goal vertex
+         */
         static auto BreadthFirstSearch(Vertex& start, const Vertex& goal) -> Vertex*;
 
         void AddVertex(Vertex& v);