int key
key integer
Definition: skip_list.cpp:34
+
void * value
pointer of value
Definition: skip_list.cpp:35
std::vector< std::shared_ptr< Node > > forward
nodes of the given one in all levels
Definition: skip_list.cpp:37
+
+
+
+
+ |
+ Algorithms_in_C++
+ 1.0.0
+
+ Set of algorithms implemented in C++.
+ |
+
+
+
+
+
+
+
+
+
+
+
+
int number_of_digits(int num)
Definition: armstrong_number.cpp:21
int binExpo(int a, int b)
Definition: binary_exponent.cpp:28
void add_digit(unsigned int value)
Definition: large_number.h:118
Definition: double_hash_hash_table.cpp:36
void pop()
Definition: stack.h:99
bool is_armstrong(int number)
Definition: armstrong_number.cpp:36
T setprecision(T... args)
int key
key value
Definition: linear_probing_hash_table.cpp:37
std::remove_reference< AdjList >::type const & getAdjList() const
Definition: cycle_check_directed_graph.cpp:103
static bool isCyclicBFS(Graph const &graph)
Definition: cycle_check_directed_graph.cpp:249
void removalInfo(int key)
Definition: quadratic_probing_hash_table.cpp:222
unsigned int getVertices() const
Definition: cycle_check_directed_graph.cpp:110
void addInfo(int key)
Definition: double_hash_hash_table.cpp:212
size_t otherHashFxn(int key)
Used for second hash function.
Definition: double_hash_hash_table.cpp:58
void addVertices(unsigned int num=1)
Definition: cycle_check_directed_graph.cpp:118
bool test1()
Definition: large_factorial.cpp:17
T inner_product(T... args)
Entry(int key=notPresent)
constructor
Definition: linear_probing_hash_table.cpp:36
int gcd(int num1, int num2)
Definition: gcd_iterative_euclidean.cpp:15
Class Complex to represent complex numbers as a field.
Definition: complex_numbers.cpp:20
std::vector< T > operator+(std::vector< T > const &A, std::vector< T > const &B)
Definition: ordinary_least_squares_regressor.cpp:204
friend std::ostream & operator<<(std::ostream &out, const large_number &a)
Definition: large_number.h:146
large_number(std::vector< unsigned char > &vec)
Definition: large_number.h:51
bool putProber(const Entry &entry, int key)
Definition: linear_probing_hash_table.cpp:98
void update_step(T *r, T *r0, const T2 quotient)
Definition: extended_euclid_algorithm.cpp:24
An implementation of hash table using double hashing algorithm.
Definition: linear_probing_hash_table.cpp:35
uint64_t double_factorial_iterative(uint64_t n)
Definition: double_factorial.cpp:17
void removalInfo(int key)
Definition: double_hash_hash_table.cpp:227
bool find(int x, int h) const
Find if a value and corresponding hash exist.
Definition: chaining.cpp:101
adaline(int num_features, const double eta=0.01f, const double accuracy=1e-5)
Definition: adaline_learning.cpp:55
Definition: trie_modern.cpp:16
void rehash()
Definition: linear_probing_hash_table.cpp:138
An implementation of hash table using quadratic probing algorithm.
void test1()
Definition: kohonen_som_topology.cpp:369
double fit(const std::vector< double > &x, const int &y)
Definition: adaline_learning.cpp:119
int main()
Definition: double_hash_hash_table.cpp:250
double arg() const
Member function to give the argument of our complex number.
Definition: complex_numbers.cpp:87
ll ans(ll n)
Definition: matrix_exponentiation.cpp:91
Entry(int key=notPresent)
constructor
Definition: double_hash_hash_table.cpp:37
Complex operator*(const Complex &other)
Operator overload of '*' on Complex class. Operator overload to be able to multiple two complex numbe...
Definition: complex_numbers.cpp:117
Definition: large_number.h:24
large_number fib(uint64_t n)
Definition: fibonacci_large.cpp:24
int main(int argc, char **argv)
Definition: kohonen_som_topology.cpp:582
static bool hasChildren(std::shared_ptr< TrieNode > node)
Definition: trie_modern.cpp:41
bool putProber(const Entry &entry, int key)
Definition: double_hash_hash_table.cpp:120
Complex operator-(const Complex &other)
Operator overload of '-' on Complex class. Operator overload to be able to subtract two complex numbe...
Definition: complex_numbers.cpp:106
int main(int argc, char **argv)
Definition: spirograph.cpp:268
Complex(const Complex &other)
Copy Constructor.
Definition: complex_numbers.cpp:58
int binExpo_alt(int a, int b)
Definition: binary_exponent.cpp:42
void explore(int, vector< bool > &)
Utility function for depth first seach algorithm this function explores the vertex which is passed in...
Definition: connected_components.cpp:101
bool putProber(const Entry &entry, int key)
Definition: quadratic_probing_hash_table.cpp:106
void display()
Definition: quadratic_probing_hash_table.cpp:142
Definition: quadratic_probing_hash_table.cpp:37
int save_nd_data(const char *fname, const std::vector< std::valarray< double >> &X)
Definition: kohonen_som_trace.cpp:58
Chain class with a given modulus.
Definition: chaining.cpp:16
double get_clock_diff(clock_t start_t, clock_t end_t)
Definition: kohonen_som_trace.cpp:452
void test2(const std::string &text)
Self test 2 - using 8x8 randomly generated key.
Definition: hill_cipher.cpp:505
Graph(unsigned int vertices, std::vector< Edge > const &edges)
Definition: cycle_check_directed_graph.cpp:88
static void test1()
Definition: hamiltons_cycle.cpp:81
bool searchingProber(const Entry &entry, int key)
Definition: linear_probing_hash_table.cpp:110
int predict(const std::vector< double > &x, double *out=nullptr)
Definition: adaline_learning.cpp:95
void tests()
Definition: complex_numbers.cpp:206
Machine learning algorithms.
const Complex & operator=(const Complex &other)
Operator overload of '=' on Complex class. Operator overload to be able to copy RHS instance of Compl...
Definition: complex_numbers.cpp:160
Entry find(int key)
Definition: quadratic_probing_hash_table.cpp:131
bool is_square(std::vector< std::vector< T >> const &A)
Definition: ordinary_least_squares_regressor.cpp:59
int activation(double x)
Definition: adaline_learning.cpp:186
size_t hashFxn(int key)
Hash a key. Uses the STL library's std::hash() function.
Definition: linear_probing_hash_table.cpp:46
int main()
Definition: gcd_recursive_euclidean.cpp:42
double update_weights(const std::valarray< double > &X, std::vector< std::vector< std::valarray< double >>> *W, std::vector< std::valarray< double >> *D, double alpha, int R)
Definition: kohonen_som_topology.cpp:200
size_t num_digits() const
Definition: large_number.h:130
void addInfo(int key)
Definition: linear_probing_hash_table.cpp:186
Definition: bellman_ford.cpp:13
Definition: bridge_finding_with_tarjan_algorithm.cpp:13
void remove(int key)
Definition: linear_probing_hash_table.cpp:173
void get_min_2d(const std::vector< std::valarray< double >> &X, double *val, int *x_idx, int *y_idx)
Definition: kohonen_som_topology.cpp:105
std::vector< std::shared_ptr< Node > > head
array of nodes
Definition: chaining.cpp:24
bool check_size_match(const std::vector< double > &x)
Definition: adaline_learning.cpp:196
int stack_idx
pointer to track stack index
Definition: paranthesis_matching.cpp:23
Definition: double_hash_hash_table.cpp:28
void test1()
Definition: kohonen_som_trace.cpp:233
void add(int x, int h)
create and add a new node with a give value and at a given height
Definition: chaining.cpp:45
void remove(int key)
Definition: quadratic_probing_hash_table.cpp:194
large_number & operator+=(large_number n)
Definition: large_number.h:192
int linearProbe(int key, bool searching)
Definition: linear_probing_hash_table.cpp:55
std::vector< std::vector< T > > operator*(std::vector< std::vector< T >> const &A, std::vector< std::vector< T >> const &B)
Definition: ordinary_least_squares_regressor.cpp:78
constexpr int MAX_ITER
Definition: adaline_learning.cpp:40
int main()
Main function.
Definition: binary_exponent.cpp:55
Definition: huffman.cpp:7
int main()
Definition: line_segment_intersection.cpp:92
int key
key value
Definition: quadratic_probing_hash_table.cpp:39
int main()
Definition: connected_components.cpp:111
Complex operator/(const Complex &other)
Operator overload of '/' on Complex class. Operator overload to be able to divide two complex numbers...
Definition: complex_numbers.cpp:142
large_number & operator++()
Definition: large_number.h:175
char digit_char(size_t i) const
Definition: large_number.h:248
unsigned char & operator[](size_t n)
Definition: large_number.h:137
int _mod
modulus of the class
Definition: chaining.cpp:27
int h(int key)
Definition: hash_search.cpp:45
const double eta
learning rate of the algorithm
Definition: adaline_learning.cpp:207
uint64_t phiFunction(uint64_t n)
Definition: eulers_totient_function.cpp:32
size_t hashFxn(int key)
Hash a key. Uses the STL library's std::hash() function.
Definition: double_hash_hash_table.cpp:47
Edge(unsigned int source, unsigned int destination)
Definition: cycle_check_directed_graph.cpp:40
void addEdge(unsigned int source, unsigned int destination)
Definition: cycle_check_directed_graph.cpp:136
void test()
Definition: armstrong_number.cpp:59
void add(int key)
Definition: quadratic_probing_hash_table.cpp:182
int main()
Definition: factorial.cpp:15
void multiply(const T n)
Definition: large_number.h:258
Complex operator~() const
Operator overload of '~' on Complex class. Operator overload of the BITWISE NOT which gives us the co...
Definition: complex_numbers.cpp:130
int main()
Definition: chaining.cpp:133
std::ostream & operator<<(std::ostream &os, const Complex &num)
Operator overload of '<<' of ostream for Complex class. Overloaded insersion operator to accommodate ...
Definition: complex_numbers.cpp:186
static void test2()
Definition: hamiltons_cycle.cpp:103
#define ll
Definition: matrix_exponentiation.cpp:33
void fit(std::array< std::vector< double >, N > const &X, std::array< int, N > const &Y)
Definition: adaline_learning.cpp:145
void test_3d_classes1(std::vector< std::valarray< double >> *data)
Definition: kohonen_som_topology.cpp:411
uint64_t fib(uint64_t n)
Definition: fibonacci_fast.cpp:30
void rehash()
Definition: quadratic_probing_hash_table.cpp:160
void test2()
Definition: kohonen_som_topology.cpp:451
bool on_segment(Point first_point, Point second_point, Point third_point)
Definition: line_segment_intersection.cpp:75
bool operator==(const Complex &a, const Complex &b)
Operator overload of '==' on Complex class. Logical Equal overload for our Complex class.
Definition: complex_numbers.cpp:175
void rehash()
Definition: double_hash_hash_table.cpp:161
std::vector< unsigned char > _digits
Definition: large_number.h:285
#define endl
Definition: matrix_exponentiation.cpp:36
void push(Type item)
Definition: stack.h:83
int main()
Definition: check_prime.cpp:45
virtual int hash(int x) const
Compute the hash of a value for current chain.
Definition: chaining.cpp:91
bool test2()
Definition: large_factorial.cpp:54
void addInfo(int key)
Definition: quadratic_probing_hash_table.cpp:207
void display()
Definition: double_hash_hash_table.cpp:143
void remove(int key)
Definition: double_hash_hash_table.cpp:199
void print(uint32_t N, const std::vector< bool > &is_prime)
Definition: sieve_of_eratosthenes.cpp:44
int main(int argc, char **argv)
Definition: hamiltons_cycle.cpp:142
Graph(unsigned int vertices, AdjList &&adjList)
Definition: cycle_check_directed_graph.cpp:76
int save_2d_data(const char *fname, const std::vector< std::valarray< double >> &X)
Definition: kohonen_som_topology.cpp:65
An implementation of hash table using linear probing algorithm.
void test_lamniscate(std::vector< std::valarray< double >> *data)
Definition: kohonen_som_trace.cpp:277
int main()
Definition: trie_modern.cpp:160
Definition: bellman_ford.cpp:7
int getConnectedComponents()
Function the calculates the connected compoents in the graph by performing the depth first search on ...
Definition: connected_components.cpp:63
Entry(int key=notPresent)
constructor
Definition: quadratic_probing_hash_table.cpp:38
int sum_of_divisor(int num)
Definition: check_amicable_pair.cpp:21
Type top()
Definition: stack.h:93
bool hamilton_cycle(const std::vector< std::vector< bool >> &routes)
Definition: hamiltons_cycle.cpp:30
int data[MAX]
test data
Definition: hash_search.cpp:24
void add(int key)
Definition: linear_probing_hash_table.cpp:161
double imag() const
Member function to get imaginary value of our complex number. Member function (getter) to access the ...
Definition: complex_numbers.cpp:70
void test()
Test function to save resulting points to a CSV file.
Definition: spirograph.cpp:93
int main()
Definition: armstrong_number.cpp:77
std::vector< std::vector< float > > get_inverse(std::vector< std::vector< T >> const &A)
Definition: ordinary_least_squares_regressor.cpp:226
bool searchingProber(const Entry &entry, int key)
Definition: double_hash_hash_table.cpp:133
int main()
Definition: complex_numbers.cpp:268
std::shared_ptr< struct Node > next
pointer to the next node
Definition: chaining.cpp:23
vector< vector< int > > adj
adj stores adjacency list representation of graph
Definition: connected_components.cpp:40
friend bool operator==(large_number const &a, large_number const &b)
Definition: large_number.h:155
friend std::ostream & operator<<(std::ostream &out, const adaline &ada)
Definition: adaline_learning.cpp:76
void tests()
Definition: double_factorial.cpp:50
constexpr double MIN_DISTANCE
Definition: kohonen_som_topology.cpp:129
void removalInfo(int key)
Definition: linear_probing_hash_table.cpp:201
void show(const struct tower *const F, const struct tower *const T, const struct tower *const U)
Definition: tower_of_hanoi.cpp:19
Definition: huffman.cpp:28
T sync_with_stdio(T... args)
double get_clock_diff(clock_t start_t, clock_t end_t)
Definition: kohonen_som_topology.cpp:577
int gcd(int *a, int n)
Definition: gcd_of_n_numbers.cpp:15
void add(int key)
Definition: double_hash_hash_table.cpp:185
int doubleHash(int key, bool searching)
Performs double hashing to resolve collisions.
Definition: double_hash_hash_table.cpp:71
int main()
Definition: fast_power.cpp:68
uint64_t double_factorial_recursive(uint64_t n)
Definition: double_factorial.cpp:30
hash_chain(int mod)
Construct a new chain object.
Definition: chaining.cpp:35
bool search(const std::string &word)
Definition: trie_modern.cpp:132
Definition: knapsack.cpp:4
int main()
Definition: linear_probing_hash_table.cpp:224
std::string add(std::string a, std::string b)
Definition: string_fibonacci.cpp:24
large_number(int n)
Definition: large_number.h:39
size_t hashFxn(int key)
Definition: quadratic_probing_hash_table.cpp:46
int quadraticProbe(int key, bool searching)
Definition: quadratic_probing_hash_table.cpp:56
char stack[MAX]
Definition: paranthesis_matching.cpp:20
int key
key value
Definition: double_hash_hash_table.cpp:38
Complex operator+(const Complex &other)
Operator overload of '+' on Complex class. Operator overload to be able to add two complex numbers.
Definition: complex_numbers.cpp:95
void extendedEuclid_1(T1 A, T1 B, T1 *GCD, T2 *x, T2 *y)
Definition: extended_euclid_algorithm.cpp:41
void push(char ch)
push byte to stack variable
Definition: paranthesis_matching.cpp:26
std::shared_ptr< TrieNode > removeWordHelper(const std::string &word, std::shared_ptr< TrieNode > curr, size_t index)
Definition: trie_modern.cpp:64
void test_3d_classes2(std::vector< std::valarray< double >> *data)
Definition: kohonen_som_topology.cpp:493
bool searchingProber(const Entry &entry, int key)
Definition: quadratic_probing_hash_table.cpp:119
char pop()
pop a byte out of stack variable
Definition: paranthesis_matching.cpp:29
void display()
Definition: linear_probing_hash_table.cpp:120
double _random(double a, double b)
Definition: kohonen_som_topology.cpp:53
void addEdge(Edge const &edge)
Definition: cycle_check_directed_graph.cpp:124
double fast_power_linear(T a, T b)
Definition: fast_power.cpp:50
void spirograph(std::array< std::pair< double, double >, N > *points, double l, double k, double rot)
Definition: spirograph.cpp:70
void display()
Display the chain.
Definition: chaining.cpp:63
Graph(unsigned int vertices, AdjList const &adjList)
Definition: cycle_check_directed_graph.cpp:68
large_number & operator++(int)
Definition: large_number.h:183
void quickSort(int arr[], int low, int high)
Definition: quick_sort.cpp:63
void test_circle(std::vector< std::valarray< double >> *data)
Definition: kohonen_som_trace.cpp:196
int main()
Definition: check_amicable_pair.cpp:68
int main()
Definition: quadratic_probing_hash_table.cpp:246
This class specifies the basic operation on a stack as a linked list.
+
+
+
+
+ |
+ Algorithms_in_C++
+ 1.0.0
+
+ Set of algorithms implemented in C++.
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
An implementation of hash table using quadratic probing algorithm.
+More...
+
+ |
+|
+using | Entry = struct Entry |
+| |
+
+ |
+|
+int | notPresent |
+| |
+|
+std::vector< Entry > | table |
+| |
+|
+int | totalSize |
+| |
+|
+int | tomb = -1 |
+| |
+|
+int | size |
+| |
+|
+bool | rehashing |
+| |
+
+
+
An implementation of hash table using quadratic probing algorithm.
+
+
+
◆ add()
+
+
+
+
+
+ | void quadratic_probing::add |
+ ( |
+ int |
+ key | ) |
+ |
+
+
+
+
Checks for load factor here
- Parameters
-
+
+ | key | key value to hash and add to table |
+
+
+
+
+
+
184 table[index].key = key;
+
+
186 if (++size /
static_cast<double>(totalSize) >= 0.5) {
+
+
+
+
+
+
+
+
+
+
◆ addInfo()
+
+
+
+
+
+ | void quadratic_probing::addInfo |
+ ( |
+ int |
+ key | ) |
+ |
+
+
+
+
Information about the adding process
- Parameters
-
+
+ | key | key value to hash and add to table |
+
+
+
+
+
+
+
+
+
212 << totalSize <<
" == " <<
hashFxn(key) % totalSize;
+
+
+
+
+
+
+
+
+
+
+
+
◆ display()
+
+
+
+
+
+ | void quadratic_probing::display |
+ ( |
+ | ) |
+ |
+
+
+
+
Displays the table
- Returns
- None
+
+
143 for (
int i = 0; i < totalSize; i++) {
+
144 if (table[i].key == notPresent) {
+
+
146 }
else if (table[i].key == tomb) {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
◆ find()
+
+
+
+
+
+ | Entry quadratic_probing::find |
+ ( |
+ int |
+ key | ) |
+ |
+
+
+
+
Get the entry instance corresponding to a key
- Parameters
-
+
+ | key | key value to search/probe |
+
+
+
+
- Returns
- if present, the entry instance
+-
+if not present, a new instance
+
+
+
133 if (index == notPresent) {
+
+
+
+
+
+
+
+
+
+
+
◆ hashFxn()
+
+
+
+
+
+ | size_t quadratic_probing::hashFxn |
+ ( |
+ int |
+ key | ) |
+ |
+
+
+
+
Hash a key
- Parameters
-
+
+
+
+
- Returns
- hash of the key
+
+
+
+
+
◆ putProber()
+
+
+
+
+
+ | bool quadratic_probing::putProber |
+ ( |
+ const Entry & |
+ entry, |
+
+
+ |
+ |
+ int |
+ key |
+
+
+ |
+ ) |
+ | |
+
+
+
+
Finds empty spot
- Parameters
-
+
+ | entry | Instance of table entry |
+ | key | key value to search/probe |
+
+
+
+
- Returns
true if key is present -
+
false if key is absent
+
+
107 if (entry.
key == notPresent || entry.
key == tomb) {
+
+
+
+
+
+
+
+
+
◆ quadraticProbe()
+
+
+
+
+
+ | int quadratic_probing::quadraticProbe |
+ ( |
+ int |
+ key, |
+
+
+ |
+ |
+ bool |
+ searching |
+
+
+ |
+ ) |
+ | |
+
+
+
+
Performs quadratic probing to resolve collisions
- Parameters
-
+
+ | key | key value to search/probe |
+ | searching | true if only searching, false1 if assigning @returns value ofnotPresent`. |
+
+
+
+
+
57 int hash =
static_cast<int>(
hashFxn(key));
+
+
+
+
+
+
+
+
+
66 if (entry.
key == notPresent) {
+
+
+
+
+
+
+
73 std::cout <<
"Found tombstone or equal hash, checking next"
+
+
+
+
+
+
+
+
+
+
+
84 std::cout <<
"Spot taken, looking at next (next index = "
+
85 << (hash +
static_cast<size_t>(
+
+
+
+
+
+
+
92 if (i == totalSize * 100) {
+
+
+
+
96 }
while (entry.
key != notPresent);
+
+
+
+
+
+
+
+
+
◆ rehash()
+
+
+
+
+
+ | void quadratic_probing::rehash |
+ ( |
+ | ) |
+ |
+
+
+
+
Rehashes the table into a bigger table
- Returns
- none
+
+
+
+
163 int oldSize = totalSize;
+
+
+
+
+
168 for (
int i = 0; i < oldSize; i++) {
+
169 if (oldTable[i].key != -1 && oldTable[i].key != notPresent) {
+
+
171 add(oldTable[i].key);
+
+
+
+
+
+
+
+
+
+
+
+
+
◆ removalInfo()
+
+
+
+
+
+ | void quadratic_probing::removalInfo |
+ ( |
+ int |
+ key | ) |
+ |
+
+
+
+
Information about removal process
- Parameters
-
+
+ | key | key value to hash and remove from table |
+
+
+
+
+
+
+
+
+
227 << totalSize <<
" == " <<
hashFxn(key) % totalSize;
+
+
+
+
+
+
+
+
+
+
+
+
◆ remove()
+
+
+
+
+
+ | void quadratic_probing::remove |
+ ( |
+ int |
+ key | ) |
+ |
+
+
+
+
Removes key. Leaves tombstone upon removal.
- Parameters
-
+
+ | key | key value to hash and remove from table |
+
+
+
+
+
+
196 if (index == notPresent) {
+
+
+
199 table[index].key = tomb;
+
+
+
+
+
+
+
+
+
+
◆ searchingProber()
+
+
+
+
+
+ | bool quadratic_probing::searchingProber |
+ ( |
+ const Entry & |
+ entry, |
+
+
+ |
+ |
+ int |
+ key |
+
+
+ |
+ ) |
+ | |
+
+
+
+
Looks for a matching key
- Parameters
-
+
+ | entry | Instance of table entry |
+ | key | key value to search/probe |
+
+
+
+
- Returns
true if key matches the entry -
+
false if key does not match the entry
+
+
120 if (entry.
key == key) {
+
+
+
+
+
+
+
+
+
bool putProber(const Entry &entry, int key)
Definition: quadratic_probing_hash_table.cpp:106
void display()
Definition: quadratic_probing_hash_table.cpp:142
Definition: quadratic_probing_hash_table.cpp:37
void remove(int key)
Definition: quadratic_probing_hash_table.cpp:194
int key
key value
Definition: quadratic_probing_hash_table.cpp:39
void rehash()
Definition: quadratic_probing_hash_table.cpp:160
std::string add(std::string a, std::string b)
Definition: string_fibonacci.cpp:24
size_t hashFxn(int key)
Definition: quadratic_probing_hash_table.cpp:46
int quadraticProbe(int key, bool searching)
Definition: quadratic_probing_hash_table.cpp:56
bool searchingProber(const Entry &entry, int key)
Definition: quadratic_probing_hash_table.cpp:119
+
+
+
+
+ |
+ Algorithms_in_C++
+ 1.0.0
+
+ Set of algorithms implemented in C++.
+ |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Storage mechanism using double-hashed keys.
+More...
+
#include <iostream>
+#include <memory>
+#include <vector>
+
+ |
+|
+using | double_hashing::Entry = struct Entry |
+| |
+
+ |
+|
+int | double_hashing::notPresent |
+| |
+|
+std::vector< Entry > | double_hashing::table |
+| |
+|
+int | double_hashing::totalSize |
+| |
+|
+int | double_hashing::tomb = -1 |
+| |
+|
+int | double_hashing::size |
+| |
+|
+bool | double_hashing::rehashing |
+| |
+
+
+
Storage mechanism using double-hashed keys.
+
- Author
- achance6
+-
+Krishna Vedala
+
- Note
- The implementation can be optimized by using OOP style.
+
+
+
◆ main()
+
+
+
+
+
+ | int main |
+ ( |
+ | ) |
+ |
+
+
+
+
Main program
- Returns
- 0 on success
+
+
251 int cmd = 0, hash = 0, key = 0;
+
252 std::cout <<
"Enter the initial size of Hash Table. = ";
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
281 if (entry.
key == double_hashing::notPresent) {
+
+
+
+
+
+
287 std::cout <<
"Enter element to generate hash = ";
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Definition: double_hash_hash_table.cpp:36
void addInfo(int key)
Definition: double_hash_hash_table.cpp:212
void removalInfo(int key)
Definition: double_hash_hash_table.cpp:227
size_t hashFxn(int key)
Hash a key. Uses the STL library's std::hash() function.
Definition: double_hash_hash_table.cpp:47
void display()
Definition: double_hash_hash_table.cpp:143
int doubleHash(int key, bool searching)
Performs double hashing to resolve collisions.
Definition: double_hash_hash_table.cpp:71
int key
key value
Definition: double_hash_hash_table.cpp:38
-
diff --git a/d7/db9/hill__cipher_8cpp_a04391124480d2a49f2dec900237b0712_cgraph.map b/d7/db9/hill__cipher_8cpp_a04391124480d2a49f2dec900237b0712_cgraph.map
index 761b91d6d..e03477b1c 100644
--- a/d7/db9/hill__cipher_8cpp_a04391124480d2a49f2dec900237b0712_cgraph.map
+++ b/d7/db9/hill__cipher_8cpp_a04391124480d2a49f2dec900237b0712_cgraph.map
@@ -1,28 +1,15 @@
diff --git a/d7/db9/hill__cipher_8cpp_a04391124480d2a49f2dec900237b0712_cgraph.md5 b/d7/db9/hill__cipher_8cpp_a04391124480d2a49f2dec900237b0712_cgraph.md5
index 0ba494811..672c8b420 100644
--- a/d7/db9/hill__cipher_8cpp_a04391124480d2a49f2dec900237b0712_cgraph.md5
+++ b/d7/db9/hill__cipher_8cpp_a04391124480d2a49f2dec900237b0712_cgraph.md5
@@ -1 +1 @@
-3a02a91d1033a360ffc54da6154b006a
\ No newline at end of file
+ff2e83e164379fa87152983b03974289
\ No newline at end of file
diff --git a/d7/db9/hill__cipher_8cpp_a04391124480d2a49f2dec900237b0712_cgraph.svg b/d7/db9/hill__cipher_8cpp_a04391124480d2a49f2dec900237b0712_cgraph.svg
index bd1b646be..9e4ab398e 100644
--- a/d7/db9/hill__cipher_8cpp_a04391124480d2a49f2dec900237b0712_cgraph.svg
+++ b/d7/db9/hill__cipher_8cpp_a04391124480d2a49f2dec900237b0712_cgraph.svg
@@ -4,7 +4,7 @@
-
+
diff --git a/d8/d89/namespacelinear__probing_a16680b8a37d442c2f208faa286e33908_cgraph_org.svg b/d8/d89/namespacelinear__probing_a16680b8a37d442c2f208faa286e33908_cgraph_org.svg
new file mode 100644
index 000000000..8e556d842
--- /dev/null
+++ b/d8/d89/namespacelinear__probing_a16680b8a37d442c2f208faa286e33908_cgraph_org.svg
@@ -0,0 +1,173 @@
+
+
+
+
+
diff --git a/d8/d89/namespacelinear__probing_a16d34fd3511626a83ab00665d7bc34d1_cgraph.map b/d8/d89/namespacelinear__probing_a16d34fd3511626a83ab00665d7bc34d1_cgraph.map
new file mode 100644
index 000000000..ef30f6bd8
--- /dev/null
+++ b/d8/d89/namespacelinear__probing_a16d34fd3511626a83ab00665d7bc34d1_cgraph.map
@@ -0,0 +1,9 @@
+
diff --git a/d8/d89/namespacelinear__probing_a16d34fd3511626a83ab00665d7bc34d1_cgraph.md5 b/d8/d89/namespacelinear__probing_a16d34fd3511626a83ab00665d7bc34d1_cgraph.md5
new file mode 100644
index 000000000..f6399dcfc
--- /dev/null
+++ b/d8/d89/namespacelinear__probing_a16d34fd3511626a83ab00665d7bc34d1_cgraph.md5
@@ -0,0 +1 @@
+1c3896266704b6477280c1a5714a8b08
\ No newline at end of file
diff --git a/d8/d89/namespacelinear__probing_a16d34fd3511626a83ab00665d7bc34d1_cgraph.svg b/d8/d89/namespacelinear__probing_a16d34fd3511626a83ab00665d7bc34d1_cgraph.svg
new file mode 100644
index 000000000..6bc648d7c
--- /dev/null
+++ b/d8/d89/namespacelinear__probing_a16d34fd3511626a83ab00665d7bc34d1_cgraph.svg
@@ -0,0 +1,125 @@
+
+
+
+
+
diff --git a/d8/d89/namespacelinear__probing_a6322209aaa91b7bbf16f96e1cc52b746_cgraph.map b/d8/d89/namespacelinear__probing_a6322209aaa91b7bbf16f96e1cc52b746_cgraph.map
new file mode 100644
index 000000000..d869359f4
--- /dev/null
+++ b/d8/d89/namespacelinear__probing_a6322209aaa91b7bbf16f96e1cc52b746_cgraph.map
@@ -0,0 +1,7 @@
+
diff --git a/d8/d89/namespacelinear__probing_a6322209aaa91b7bbf16f96e1cc52b746_cgraph.md5 b/d8/d89/namespacelinear__probing_a6322209aaa91b7bbf16f96e1cc52b746_cgraph.md5
new file mode 100644
index 000000000..cad561f73
--- /dev/null
+++ b/d8/d89/namespacelinear__probing_a6322209aaa91b7bbf16f96e1cc52b746_cgraph.md5
@@ -0,0 +1 @@
+fa59d30a6fedf471602fec17d8531f1f
\ No newline at end of file
diff --git a/d8/d89/namespacelinear__probing_a6322209aaa91b7bbf16f96e1cc52b746_cgraph.svg b/d8/d89/namespacelinear__probing_a6322209aaa91b7bbf16f96e1cc52b746_cgraph.svg
new file mode 100644
index 000000000..c889abf89
--- /dev/null
+++ b/d8/d89/namespacelinear__probing_a6322209aaa91b7bbf16f96e1cc52b746_cgraph.svg
@@ -0,0 +1,83 @@
+
+
+
+
+
diff --git a/d8/d89/namespacelinear__probing_a6a082dc1426a79f866cee6b370df37b0_cgraph.map b/d8/d89/namespacelinear__probing_a6a082dc1426a79f866cee6b370df37b0_cgraph.map
new file mode 100644
index 000000000..66866bc30
--- /dev/null
+++ b/d8/d89/namespacelinear__probing_a6a082dc1426a79f866cee6b370df37b0_cgraph.map
@@ -0,0 +1,9 @@
+
diff --git a/d8/d89/namespacelinear__probing_a6a082dc1426a79f866cee6b370df37b0_cgraph.md5 b/d8/d89/namespacelinear__probing_a6a082dc1426a79f866cee6b370df37b0_cgraph.md5
new file mode 100644
index 000000000..9d74d9d1c
--- /dev/null
+++ b/d8/d89/namespacelinear__probing_a6a082dc1426a79f866cee6b370df37b0_cgraph.md5
@@ -0,0 +1 @@
+c898350363750456f64ef636d8162f8b
\ No newline at end of file
diff --git a/d8/d89/namespacelinear__probing_a6a082dc1426a79f866cee6b370df37b0_cgraph.svg b/d8/d89/namespacelinear__probing_a6a082dc1426a79f866cee6b370df37b0_cgraph.svg
new file mode 100644
index 000000000..11a2594c0
--- /dev/null
+++ b/d8/d89/namespacelinear__probing_a6a082dc1426a79f866cee6b370df37b0_cgraph.svg
@@ -0,0 +1,213 @@
+
+
+
+
+
+
diff --git a/d8/d89/namespacelinear__probing_a6a082dc1426a79f866cee6b370df37b0_cgraph_org.svg b/d8/d89/namespacelinear__probing_a6a082dc1426a79f866cee6b370df37b0_cgraph_org.svg
new file mode 100644
index 000000000..34b16c852
--- /dev/null
+++ b/d8/d89/namespacelinear__probing_a6a082dc1426a79f866cee6b370df37b0_cgraph_org.svg
@@ -0,0 +1,125 @@
+
+
+
+
+
diff --git a/d8/d89/namespacelinear__probing_a75854f5aa216e61219154c62167ce8f0_cgraph.map b/d8/d89/namespacelinear__probing_a75854f5aa216e61219154c62167ce8f0_cgraph.map
new file mode 100644
index 000000000..6a5eca68f
--- /dev/null
+++ b/d8/d89/namespacelinear__probing_a75854f5aa216e61219154c62167ce8f0_cgraph.map
@@ -0,0 +1,10 @@
+
diff --git a/d8/d89/namespacelinear__probing_a75854f5aa216e61219154c62167ce8f0_cgraph.md5 b/d8/d89/namespacelinear__probing_a75854f5aa216e61219154c62167ce8f0_cgraph.md5
new file mode 100644
index 000000000..ccfed3244
--- /dev/null
+++ b/d8/d89/namespacelinear__probing_a75854f5aa216e61219154c62167ce8f0_cgraph.md5
@@ -0,0 +1 @@
+76f406586f207174e06115d9d25b3aa5
\ No newline at end of file
diff --git a/d8/d89/namespacelinear__probing_a75854f5aa216e61219154c62167ce8f0_cgraph.svg b/d8/d89/namespacelinear__probing_a75854f5aa216e61219154c62167ce8f0_cgraph.svg
new file mode 100644
index 000000000..a8e83d37d
--- /dev/null
+++ b/d8/d89/namespacelinear__probing_a75854f5aa216e61219154c62167ce8f0_cgraph.svg
@@ -0,0 +1,240 @@
+
+
+
+
+
+
diff --git a/d8/d89/namespacelinear__probing_a75854f5aa216e61219154c62167ce8f0_cgraph_org.svg b/d8/d89/namespacelinear__probing_a75854f5aa216e61219154c62167ce8f0_cgraph_org.svg
new file mode 100644
index 000000000..bd067fdd4
--- /dev/null
+++ b/d8/d89/namespacelinear__probing_a75854f5aa216e61219154c62167ce8f0_cgraph_org.svg
@@ -0,0 +1,152 @@
+
+
+
+
+
diff --git a/d8/d89/namespacelinear__probing_abcf8d033f8115f39f3c93cfb6cee0b28_cgraph.map b/d8/d89/namespacelinear__probing_abcf8d033f8115f39f3c93cfb6cee0b28_cgraph.map
new file mode 100644
index 000000000..c3d5bfe14
--- /dev/null
+++ b/d8/d89/namespacelinear__probing_abcf8d033f8115f39f3c93cfb6cee0b28_cgraph.map
@@ -0,0 +1,8 @@
+
diff --git a/d8/d89/namespacelinear__probing_abcf8d033f8115f39f3c93cfb6cee0b28_cgraph.md5 b/d8/d89/namespacelinear__probing_abcf8d033f8115f39f3c93cfb6cee0b28_cgraph.md5
new file mode 100644
index 000000000..cc12766de
--- /dev/null
+++ b/d8/d89/namespacelinear__probing_abcf8d033f8115f39f3c93cfb6cee0b28_cgraph.md5
@@ -0,0 +1 @@
+432defc68e82abbb7827f83137a82d38
\ No newline at end of file
diff --git a/d8/d89/namespacelinear__probing_abcf8d033f8115f39f3c93cfb6cee0b28_cgraph.svg b/d8/d89/namespacelinear__probing_abcf8d033f8115f39f3c93cfb6cee0b28_cgraph.svg
new file mode 100644
index 000000000..138cc52db
--- /dev/null
+++ b/d8/d89/namespacelinear__probing_abcf8d033f8115f39f3c93cfb6cee0b28_cgraph.svg
@@ -0,0 +1,104 @@
+
+
+
+
+
diff --git a/d8/d89/namespacelinear__probing_ad87b71d810901fab69c4ad9d4d0fa635_cgraph.map b/d8/d89/namespacelinear__probing_ad87b71d810901fab69c4ad9d4d0fa635_cgraph.map
new file mode 100644
index 000000000..2602892ff
--- /dev/null
+++ b/d8/d89/namespacelinear__probing_ad87b71d810901fab69c4ad9d4d0fa635_cgraph.map
@@ -0,0 +1,4 @@
+
diff --git a/d8/d89/namespacelinear__probing_ad87b71d810901fab69c4ad9d4d0fa635_cgraph.md5 b/d8/d89/namespacelinear__probing_ad87b71d810901fab69c4ad9d4d0fa635_cgraph.md5
new file mode 100644
index 000000000..a072976a2
--- /dev/null
+++ b/d8/d89/namespacelinear__probing_ad87b71d810901fab69c4ad9d4d0fa635_cgraph.md5
@@ -0,0 +1 @@
+12db28c16ccf50031901a745d926471f
\ No newline at end of file
diff --git a/d8/d89/namespacelinear__probing_ad87b71d810901fab69c4ad9d4d0fa635_cgraph.svg b/d8/d89/namespacelinear__probing_ad87b71d810901fab69c4ad9d4d0fa635_cgraph.svg
new file mode 100644
index 000000000..512fd00fd
--- /dev/null
+++ b/d8/d89/namespacelinear__probing_ad87b71d810901fab69c4ad9d4d0fa635_cgraph.svg
@@ -0,0 +1,37 @@
+
+
+
+
+
diff --git a/d8/d8a/exponential__search_8cpp.html b/d8/d8a/exponential__search_8cpp.html
index 70d44c141..827aaca6a 100644
--- a/d8/d8a/exponential__search_8cpp.html
+++ b/d8/d8a/exponential__search_8cpp.html
@@ -194,13 +194,7 @@ template<class Type >
1.8.18
+