OpenSoure_Repos/TheAlgorithms-C-Plus-Plus
1
0
Fork 0
mirror of https://hub.njuu.cf/TheAlgorithms/C-Plus-Plus.git synced 2023-10-11 13:05:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix: clang-tidy fixes applied

Browse Source
This commit is contained in:
weiss-ben 2022-09-23 16:24:14 +03:00
parent 102937d1d0
commit 5ef67bfe44
1 changed files with 84 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

163
search/median_search2.cpp
View File

@ -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 <iostream> /// for IO operations
#include <cassert> /// for assert
#include <cassert> /// for assert
#include <iostream> /// 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;
}