#### Median Search 2

w
```/**
* @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.
*
* Here are some example lists you can use to see how the algorithm works
* A = [1,2,3,4,5]
* B = [1,2,3,4,5,6]
* print median(A) #should be 39
* print median(B) #should be 4
*
* @author [Benjamin Weiss](https://github.com/weiss-ben)
* @see median_search.cpp
*/

#include <cassert>   /// for assert
#include <iostream>  /// for IO operations

/**
*/
struct ListNode {
int val{0};               ///< the value stored in the node
ListNode* next{nullptr};  ///< pointer to the next node
ListNode() = default;     ///< default constructor
explicit ListNode(int x)
: val(x) {}  ///< 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
* @brief Search algorithms
*/
namespace search {
/**
* @namespace median_search
* @brief Functions for the Median Search algorithm implementation. Wkipedia
*/
namespace median_search2 {
/**
* This function searches for the median of a linked list.
* @returns Median node of the linked list.
*/
return nullptr;
}

// Fast and slow pointers
ListNode* fastptr = nullptr;
ListNode* slowptr = fastptr = head;

// 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

/**
* @brief Self-test implementations
* @returns void
*/
static void test() {

for (int i = 2; i < 6; ++i) {
// Allocate next
auto* temp1 = new ListNode;
temp1->val = i;

temp->next = temp1;
temp = temp1;
}
temp->next = nullptr;

assert(3 == median->val);  // 3 is the value of the median node.
std::cout << "test case:1 passed\n";

// Test case # 2

for (int i = 2; i < 7; ++i) {
// Allocate next
auto* temp3 = new ListNode;
temp3->val = i;

temp2->next = temp3;
temp2 = temp3;
}
temp2->next = nullptr;

assert(4 == median1->val);  // 4 is the value of the median node.
std::cout << "test case:2 passed\n";

delete temp;

delete temp2;

std::cout << "--All tests passed--\n";
}

/**
* @brief Main function
* @returns 0 on exit
*/
int main() {
test();  // run self-test implementations
return 0;
}
```