From 5ef67bfe44ed8e9f80359688afa14fd2b70323f3 Mon Sep 17 00:00:00 2001 From: weiss-ben Date: Fri, 23 Sep 2022 16:24:14 +0300 Subject: [PATCH] fix: clang-tidy fixes applied --- search/median_search2.cpp | 163 ++++++++++++++++++++------------------ 1 file changed, 84 insertions(+), 79 deletions(-) diff --git a/search/median_search2.cpp b/search/median_search2.cpp index 0c30cf7ad..57309e70d 100644 --- a/search/median_search2.cpp +++ b/search/median_search2.cpp @@ -1,12 +1,16 @@ /** * @file * @brief Given a linked list L[0,....,n] of n numbers, find the middle node. - * - * @details The technique utilized in this implementation is the ["Floyd's tortoise and hare"](https://en.wikipedia.org/wiki/Cycle_detection#Floyd's_tortoise_and_hare) approach. - * This technique uses two pointers that iterate through the list at different 'speeds' in order to solve problems. - * In this implementation, for every iteration the slow pointer advances one node while the fast pointer advances two nodes. - * The result of this is that since the fast pointer moves twice as fast as the slow pointer, when the fast pointer reaches the end of the list - * the slow pointer will be pointing to the middle node of the list. + * + * @details The technique utilized in this implementation is the ["Floyd's + * tortoise and + * hare"](https://en.wikipedia.org/wiki/Cycle_detection#Floyd's_tortoise_and_hare) + * approach. This technique uses two pointers that iterate through the list at + * different 'speeds' in order to solve problems. In this implementation, for + * every iteration the slow pointer advances one node while the fast pointer + * advances two nodes. The result of this is that since the fast pointer moves + * twice as fast as the slow pointer, when the fast pointer reaches the end of + * the list the slow pointer will be pointing to the middle node of the list. * * Here are some example lists you can use to see how the algorithm works * A = [1,2,3,4,5] @@ -17,19 +21,24 @@ * @author [Benjamin Weiss](https://github.com/weiss-ben) */ -#include /// for IO operations -#include /// for assert +#include /// for assert +#include /// for IO operations /** * Definition for singly-linked list. */ struct ListNode { - int val; ///< the value stored in the node - ListNode *next; ///< pointer to the next node - ListNode() : val(0), next(nullptr) {} ///< default constructor - ListNode(int x) : val(x), next(nullptr) {} ///< constructor with value for node->val provided - ListNode(int x, ListNode *next) : val(x), next(next) {} ///< constructor with values provided for node->val and node->next - }; + int val; ///< the value stored in the node + ListNode* next; ///< pointer to the next node + ListNode() : val(0), next(nullptr) {} ///< default constructor + ListNode(int x) + : val(x), + next(nullptr) {} ///< constructor with value for node->val provided + ListNode(int x, ListNode* next) + : val(x), + next(next) { + } ///< constructor with values provided for node->val and node->next +}; /** * @namespace search @@ -38,29 +47,29 @@ struct ListNode { namespace search { /** * @namespace median_search - * @brief Functions for the Median Search algorithm implementation. Wkipedia link to algorithm: https://en.wikipedia.org/wiki/Median_search + * @brief Functions for the Median Search algorithm implementation. Wkipedia + * link to algorithm: https://en.wikipedia.org/wiki/Median_search */ namespace median_search2 { /** -* This function searches for the median of a linked list. -* @param head The head of the linked list. -* @returns Median node of the linked list. -*/ + * This function searches for the median of a linked list. + * @param head The head of the linked list. + * @returns Median node of the linked list. + */ ListNode* middleNode(ListNode* head) { - if(!head) + if (!head) return nullptr; - - //Fast and slow pointers + + // Fast and slow pointers ListNode* fastptr; ListNode* slowptr = fastptr = head; - - // fast jumps 2 while slow jumps 1 - while(fastptr->next && fastptr->next->next) { + + // fast jumps 2 while slow jumps 1 + while (fastptr->next && fastptr->next->next) { slowptr = slowptr->next; fastptr = fastptr->next->next; } return (fastptr->next) ? slowptr->next : slowptr; - } } // namespace median_search2 } // namespace search @@ -70,63 +79,59 @@ ListNode* middleNode(ListNode* head) { * @returns void */ static void test() { - ListNode* head = new ListNode; - head->val = 1; - - ListNode* temp1 = head; - for(int i = 1; i < 6; ++i) - { - ListNode* temp2 = new ListNode; - temp2->val = i; - - temp1->next = temp2; - temp1 = temp2; - } - - ListNode* median = search::median_search2::middleNode(head); - assert(3 == median->val); // 3 is the value of the median node. - std::cout << "test case:1 passed\n"; - - // Clean up - while(head) - { - ListNode* t = head->next; - delete head; - } - - head = new ListNode; - head->val = 1; - - temp1 = head; - for(int i = 1; i < 7; ++i) - { - ListNode* temp2 = new ListNode; - temp2->val = i; - - temp1->next = temp2; - temp1 = temp2; - } - - median = search::median_search2::middleNode(head); - assert(4 == median->val); // 3 is the value of the median node. - std::cout << "test case:1 passed\n"; - - // Clean up - while(head) - { - ListNode* t = head->next; - delete head; - } - std::cout << "test case:2 passed\n"; - std::cout << "--All tests passed--\n"; + ListNode* head = new ListNode; + head->val = 1; + + ListNode* temp1 = head; + for (int i = 1; i < 6; ++i) { + auto temp2 = new ListNode; + temp2->val = i; + + temp1->next = temp2; + temp1 = temp2; + } + + ListNode* median = search::median_search2::middleNode(head); + assert(3 == median->val); // 3 is the value of the median node. + std::cout << "test case:1 passed\n"; + + // Clean up + while (head) { + ListNode* t = head->next; + delete head; + } + + head = new ListNode; + head->val = 1; + + temp1 = head; + for (int i = 1; i < 7; ++i) { + ListNode* temp2 = new ListNode; + temp2->val = i; + + temp1->next = temp2; + temp1 = temp2; + } + + median = search::median_search2::middleNode(head); + assert(4 == median->val); // 3 is the value of the median node. + std::cout << "test case:1 passed\n"; + + // Clean up + while (head) { + ListNode* t = head; + head = head->next; + delete t; + } + std::cout << "test case:2 passed\n"; + std::cout << "--All tests passed--\n"; } /** * @brief Main function * @returns 0 on exit */ -int main() -{ - test(); // run self-test implementations - return 0; +int main() { + test(); // run self-test implementations + return 0; }