diff --git a/annotated.html b/annotated.html index cddc56d06..a0838d40f 100644 --- a/annotated.html +++ b/annotated.html @@ -154,82 +154,85 @@ $(document).ready(function(){initNavTree('annotated.html',''); initResizable();  ▼Noperations_on_datastructuresFor std::vector  ►Ninorder_traversal_of_bst  CNodeA Node structure representing a single node in BST - ►Ntrie_operations - CTnodeClass defining the structure of trie node and containing the methods to perform operations on them - ▼NothersFor vector - ►Niterative_tree_traversals - CBinaryTreeDefines the functions associated with the binary tree - CNodeDefines the structure of a node of the tree - ►Nlru_cache - CLRUCacheLRU cache class - ►Npostfix_expression - CStackCreates an array to be used as stack for storing values - ▼NprobabilityProbability algorithms - ►Ngeometric_dist - Cgeometric_distributionA class to model the geometric distribution - ►Nwindowed_median - CWindowedMedianA class to calculate the median of a leading sliding window at the back of a stream of integer values - ▼Nquadratic_probingAn implementation of hash table using quadratic probing algorithm - CEntry - ▼Nrange_queriesAlgorithms and Data Structures that support range queries and updates - ►Nheavy_light_decomposition - CHLDThe Heavy-Light Decomposition class - CSGSegment Tree, to store heavy chains - CTreeA Basic Tree, which supports binary lifting - ►CperSegTreeRange query here is range sum, but the code can be modified to make different queries like range max or min - CNode - ▼NsearchFor std::vector - ►Nsublist_search - CNodeA Node structure representing a single link Node in a linked list - ▼NstatisticsStatistical algorithms - Cstats_computer1 - Cstats_computer2 - ▼NstdSTL namespace - Cis_arithmetic< uint128_t > - Cis_arithmetic< uint256_t > - Cis_integral< uint128_t > - Cis_integral< uint256_t > - Cis_unsigned< uint128_t > - Cis_unsigned< uint256_t > - ▼Cbinary_search_treeThe Binary Search Tree class - Cbst_nodeA struct to represent a node in the Binary Search Tree - CBtree - Ccll - Ccompare - CCompareComparator class for priority queue - CComplexClass Complex to represent complex numbers as a field - CCycleCheck - Cdouble_linked_list - CEasterYearMonthDayFor IO operations - CEdge - CFCFSClass which implements the FCFS scheduling algorithm - CFenwickTree - CGraph - Chash_chainChain class with a given modulus - CItem - Clarge_number - Clinkedlist - Clist - CMinHeap - CMinHeapNode - Cmst - CNode - Cnode - CPoint - Cquery - CQueue - Cqueue - CRBtree - CSegmentIntersection - CSolution - Cstack - Cstack_linkedList - CTestCasesClass encapsulating the necessary test cases - Ctower - ▼CTrie - CTrieNode - Cuint128_tClass for 128-bit unsigned integer - Cuint256_tClass for 256-bit unsigned integer + ►Nreverse_binary_tree + CBinaryTreeA Binary Tree class that implements a Binary Search Tree (BST) by default + CNodeA Node struct that represents a single node in a Binary Tree + ►Ntrie_operations + CTnodeClass defining the structure of trie node and containing the methods to perform operations on them + ▼NothersFor vector + ►Niterative_tree_traversals + CBinaryTreeDefines the functions associated with the binary tree + CNodeDefines the structure of a node of the tree + ►Nlru_cache + CLRUCacheLRU cache class + ►Npostfix_expression + CStackCreates an array to be used as stack for storing values + ▼NprobabilityProbability algorithms + ►Ngeometric_dist + Cgeometric_distributionA class to model the geometric distribution + ►Nwindowed_median + CWindowedMedianA class to calculate the median of a leading sliding window at the back of a stream of integer values + ▼Nquadratic_probingAn implementation of hash table using quadratic probing algorithm + CEntry + ▼Nrange_queriesAlgorithms and Data Structures that support range queries and updates + ►Nheavy_light_decomposition + CHLDThe Heavy-Light Decomposition class + CSGSegment Tree, to store heavy chains + CTreeA Basic Tree, which supports binary lifting + ►CperSegTreeRange query here is range sum, but the code can be modified to make different queries like range max or min + CNode + ▼NsearchFor std::vector + ►Nsublist_search + CNodeA Node structure representing a single link Node in a linked list + ▼NstatisticsStatistical algorithms + Cstats_computer1 + Cstats_computer2 + ▼NstdSTL namespace + Cis_arithmetic< uint128_t > + Cis_arithmetic< uint256_t > + Cis_integral< uint128_t > + Cis_integral< uint256_t > + Cis_unsigned< uint128_t > + Cis_unsigned< uint256_t > + ▼Cbinary_search_treeThe Binary Search Tree class + Cbst_nodeA struct to represent a node in the Binary Search Tree + CBtree + Ccll + Ccompare + CCompareComparator class for priority queue + CComplexClass Complex to represent complex numbers as a field + CCycleCheck + Cdouble_linked_list + CEasterYearMonthDayFor IO operations + CEdge + CFCFSClass which implements the FCFS scheduling algorithm + CFenwickTree + CGraph + Chash_chainChain class with a given modulus + CItem + Clarge_number + Clinkedlist + Clist + CMinHeap + CMinHeapNode + Cmst + Cnode + CNode + CPoint + Cquery + CQueue + Cqueue + CRBtree + CSegmentIntersection + CSolution + Cstack + Cstack_linkedList + CTestCasesClass encapsulating the necessary test cases + Ctower + ▼CTrie + CTrieNode + Cuint128_tClass for 128-bit unsigned integer + Cuint256_tClass for 256-bit unsigned integer diff --git a/annotated_dup.js b/annotated_dup.js index 639773412..ff673b2e9 100644 --- a/annotated_dup.js +++ b/annotated_dup.js @@ -78,6 +78,10 @@ var annotated_dup = [ "inorder_traversal_of_bst", null, [ [ "Node", "d5/db5/classoperations__on__datastructures_1_1inorder__traversal__of__bst_1_1_node.html", "d5/db5/classoperations__on__datastructures_1_1inorder__traversal__of__bst_1_1_node" ] ] ], + [ "reverse_binary_tree", null, [ + [ "BinaryTree", "de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree.html", "de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree" ], + [ "Node", "d8/dfd/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node.html", "d8/dfd/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node" ] + ] ], [ "trie_operations", null, [ [ "Tnode", "d0/d5f/classoperations__on__datastructures_1_1trie__operations_1_1_tnode.html", "d0/d5f/classoperations__on__datastructures_1_1trie__operations_1_1_tnode" ] ] ] @@ -151,8 +155,8 @@ var annotated_dup = [ "MinHeap", "d2/d05/class_min_heap.html", "d2/d05/class_min_heap" ], [ "MinHeapNode", "d5/d29/struct_min_heap_node.html", null ], [ "mst", "d1/d77/structmst.html", null ], - [ "Node", "db/d8b/struct_node.html", null ], [ "node", "d5/da1/structnode.html", "d5/da1/structnode" ], + [ "Node", "db/d8b/struct_node.html", null ], [ "Point", "d8/dc8/struct_point.html", "d8/dc8/struct_point" ], [ "query", "dd/d1b/structquery.html", null ], [ "Queue", "dc/db5/struct_queue.html", null ], diff --git a/classes.html b/classes.html index 1d5708938..0ff442eee 100644 --- a/classes.html +++ b/classes.html @@ -100,7 +100,7 @@ $(document).ready(function(){initNavTree('classes.html',''); initResizable(); })
adaline (machine_learning)
AyStarSearch (machine_learning::aystar_search)
B
-
binary_search_tree
BinaryTree (others::iterative_tree_traversals)
binary_search_tree::bst_node
Btree
+
binary_search_tree
BinaryTree (operations_on_datastructures::reverse_binary_tree)
BinaryTree (others::iterative_tree_traversals)
binary_search_tree::bst_node
Btree
C
cll
compare
Compare
AyStarSearch::comparison_operator (machine_learning::aystar_search)
Complex
Convexhull (geometry::jarvis)
CycleCheck
@@ -130,7 +130,7 @@ $(document).ready(function(){initNavTree('classes.html',''); initResizable(); })
MinHeap
MinHeapNode
mst
N
-
NCRModuloP (math::ncr_modulo_p)
NeuralNetwork (machine_learning::neural_network)
Node (data_structures::linked_list)
Node (data_structures)
Node (data_structures::tree_234)
Trie::Node (data_structures::trie_using_hashmap)
Node
node
Node (operations_on_datastructures::inorder_traversal_of_bst)
Node (others::iterative_tree_traversals)
perSegTree::Node (range_queries)
Node (search::sublist_search)
+
NCRModuloP (math::ncr_modulo_p)
NeuralNetwork (machine_learning::neural_network)
Node (data_structures::linked_list)
Node (data_structures)
Node (data_structures::tree_234)
Trie::Node (data_structures::trie_using_hashmap)
node
Node
Node (operations_on_datastructures::inorder_traversal_of_bst)
Node (operations_on_datastructures::reverse_binary_tree)
Node (others::iterative_tree_traversals)
perSegTree::Node (range_queries)
Node (search::sublist_search)
P
perSegTree (range_queries)
Point (ciphers::elliptic_curve_key_exchange)
Point (geometry::jarvis)
Point
diff --git a/d0/d8b/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node-members.html b/d0/d8b/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node-members.html new file mode 100644 index 000000000..f1e70846f --- /dev/null +++ b/d0/d8b/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node-members.html @@ -0,0 +1,112 @@ + + + + + + + +Algorithms_in_C++: Member List + + + + + + + + + + + + + + + +
+
+ + + + + + +
+
Algorithms_in_C++ 1.0.0 +
+
Set of algorithms implemented in C++.
+
+
+ + + + + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+ +
+ +
+
operations_on_datastructures::reverse_binary_tree::Node Member List
+
+
+ +

This is the complete list of members for operations_on_datastructures::reverse_binary_tree::Node, including all inherited members.

+ + + + + +
dataoperations_on_datastructures::reverse_binary_tree::Node
leftoperations_on_datastructures::reverse_binary_tree::Node
Node(int64_t _data)operations_on_datastructures::reverse_binary_tree::Nodeinlineexplicit
rightoperations_on_datastructures::reverse_binary_tree::Node
+
+ + + + diff --git a/d4/db6/reverse__binary__tree_8cpp.html b/d4/db6/reverse__binary__tree_8cpp.html new file mode 100644 index 000000000..578871bc1 --- /dev/null +++ b/d4/db6/reverse__binary__tree_8cpp.html @@ -0,0 +1,243 @@ + + + + + + + +Algorithms_in_C++: operations_on_datastructures/reverse_binary_tree.cpp File Reference + + + + + + + + + + + + + + + +
+
+ + + + + + +
+
Algorithms_in_C++ 1.0.0 +
+
Set of algorithms implemented in C++.
+
+
+ + + + + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+ +
+ +
+
+Classes | +Namespaces | +Functions
+
reverse_binary_tree.cpp File Reference
+
+
+ +

Implementation for the Reversing a Binary Tree recursively algorithm. +More...

+
#include <cassert>
+#include <iostream>
+#include <queue>
+#include <vector>
+
+Include dependency graph for reverse_binary_tree.cpp:
+
+
+
+
+
+ + + + + + + +

+Classes

struct  operations_on_datastructures::reverse_binary_tree::Node
 A Node struct that represents a single node in a Binary Tree. More...
 
class  operations_on_datastructures::reverse_binary_tree::BinaryTree
 A Binary Tree class that implements a Binary Search Tree (BST) by default. More...
 
+ + + + + + + + + + +

+Namespaces

namespace  operations_on_datastructures
 for std::vector
 
namespace  reverse_binary_tree
 Functions for the Reverse a Binary Tree implementation.
 
namespace  tests
 Testcases to check Reversal of Binary Tree.
 
+ + + + + + + + + + + + + + + + +

+Functions

void tests::test1 ()
 < Use the BinaryTree More...
 
void tests::test2 ()
 A Test to check an edge case (NULL root element) More...
 
void tests::test3 ()
 A Test to check correct reversal of a Binary Tree. More...
 
static void test ()
 Function to test the correctness of the Tree Reversal. More...
 
int main ()
 main function More...
 
+

Detailed Description

+

Implementation for the Reversing a Binary Tree recursively algorithm.

+

A binary tree can be reversed by swapping the left and right child of a node at each node, starting from the root, and cascading below. This solution aims to provide an implementation of a recursive reversal of a binary tree.

Author
Alvin
+

Function Documentation

+ +

◆ main()

+ +
+
+ + + + + + + + +
int main (void )
+
+ +

main function

+
Returns
0 on exit
+
252 {
+
253 test(); // run self-test implementations
+
254 return 0;
+
255}
+
test
static void test()
Function to test the correctness of the Tree Reversal.
Definition: reverse_binary_tree.cpp:242
+
+Here is the call graph for this function:
+
+
+
+
+ +
+
+ +

◆ test()

+ +
+
+ + + + + +
+ + + + + + + +
static void test ()
+ 		+static
+
+ +

Function to test the correctness of the Tree Reversal.

+

< Single element test

+

< No element test

+

< Correct reversal test

+
242 {
+
243 tests::test1(); ///< Single element test
+
244 tests::test2(); ///< No element test
+
245 tests::test3(); ///< Correct reversal test
+
246}
+
tests::test1
void test1()
< Use the BinaryTree
Definition: reverse_binary_tree.cpp:167
+
tests::test3
void test3()
A Test to check correct reversal of a Binary Tree.
Definition: reverse_binary_tree.cpp:212
+
tests::test2
void test2()
A Test to check an edge case (NULL root element)
Definition: reverse_binary_tree.cpp:191
+
+Here is the call graph for this function:
+
+
+
+
+ +
+
+
+
+ + + + diff --git a/d4/db6/reverse__binary__tree_8cpp.js b/d4/db6/reverse__binary__tree_8cpp.js new file mode 100644 index 000000000..cd5c5aa54 --- /dev/null +++ b/d4/db6/reverse__binary__tree_8cpp.js @@ -0,0 +1,10 @@ +var reverse__binary__tree_8cpp = +[ + [ "operations_on_datastructures::reverse_binary_tree::Node", "d8/dfd/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node.html", "d8/dfd/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node" ], + [ "operations_on_datastructures::reverse_binary_tree::BinaryTree", "de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree.html", "de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree" ], + [ "main", "d4/db6/reverse__binary__tree_8cpp.html#ae66f6b31b5ad750f1fe042a706a4e3d4", null ], + [ "test", "d4/db6/reverse__binary__tree_8cpp.html#aa8dca7b867074164d5f45b0f3851269d", null ], + [ "test1", "d4/db6/reverse__binary__tree_8cpp.html#a167c24bd817469ae47358d12e034f2d5", null ], + [ "test2", "d4/db6/reverse__binary__tree_8cpp.html#abdd77344d4af8fd56d14a5cabbf2f669", null ], + [ "test3", "d4/db6/reverse__binary__tree_8cpp.html#aa515639572647508b94986489aab6d76", null ] +]; \ No newline at end of file diff --git a/d4/db6/reverse__binary__tree_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.map b/d4/db6/reverse__binary__tree_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.map new file mode 100644 index 000000000..2e743903c --- /dev/null +++ b/d4/db6/reverse__binary__tree_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.map @@ -0,0 +1,7 @@ + + + + + + + diff --git a/d4/db6/reverse__binary__tree_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.md5 b/d4/db6/reverse__binary__tree_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.md5 new file mode 100644 index 000000000..44cd4087a --- /dev/null +++ b/d4/db6/reverse__binary__tree_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.md5 @@ -0,0 +1 @@ +032e1fa8d12e347f799acaf916fb3b6d \ No newline at end of file diff --git a/d4/db6/reverse__binary__tree_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.svg b/d4/db6/reverse__binary__tree_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.svg new file mode 100644 index 000000000..56e2a608a --- /dev/null +++ b/d4/db6/reverse__binary__tree_8cpp_aa8dca7b867074164d5f45b0f3851269d_cgraph.svg @@ -0,0 +1,88 @@ + + + + + + +test + + + +Node1 + + +test + + + + + +Node2 + + +tests::test1 + + + + + +Node1->Node2 + + + + + +Node4 + + +tests::test2 + + + + + +Node1->Node4 + + + + + +Node5 + + +tests::test3 + + + + + +Node1->Node5 + + + + + +Node3 + + +std::vector::size + + + + + +Node2->Node3 + + + + + +Node4->Node3 + + + + + diff --git a/d4/db6/reverse__binary__tree_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.map b/d4/db6/reverse__binary__tree_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.map new file mode 100644 index 000000000..7a91d8e54 --- /dev/null +++ b/d4/db6/reverse__binary__tree_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.map @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/d4/db6/reverse__binary__tree_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.md5 b/d4/db6/reverse__binary__tree_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.md5 new file mode 100644 index 000000000..e7dbfc334 --- /dev/null +++ b/d4/db6/reverse__binary__tree_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.md5 @@ -0,0 +1 @@ +81c211f6003bcb1f42078a511f34fc43 \ No newline at end of file diff --git a/d4/db6/reverse__binary__tree_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg b/d4/db6/reverse__binary__tree_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg new file mode 100644 index 000000000..1c347edf3 --- /dev/null +++ b/d4/db6/reverse__binary__tree_8cpp_ae66f6b31b5ad750f1fe042a706a4e3d4_cgraph.svg @@ -0,0 +1,103 @@ + + + + + + +main + + + +Node1 + + +main + + + + + +Node2 + + +test + + + + + +Node1->Node2 + + + + + +Node3 + + +tests::test1 + + + + + +Node2->Node3 + + + + + +Node5 + + +tests::test2 + + + + + +Node2->Node5 + + + + + +Node6 + + +tests::test3 + + + + + +Node2->Node6 + + + + + +Node4 + + +std::vector::size + + + + + +Node3->Node4 + + + + + +Node5->Node4 + + + + + diff --git a/d5/d88/md__d_i_r_e_c_t_o_r_y.html b/d5/d88/md__d_i_r_e_c_t_o_r_y.html index da997c9a7..a5db82e7a 100644 --- a/d5/d88/md__d_i_r_e_c_t_o_r_y.html +++ b/d5/d88/md__d_i_r_e_c_t_o_r_y.html @@ -370,6 +370,7 @@ Operations On Datastructures
  • Inorder Successor Of Bst
  • Intersection Of 2 Arrays
  • Reverse A Linked List Using Recusion
    • +
  • Reverse Binary Tree
  • Selectionsortlinkedlist
  • Trie Multiple Search
  • Union Of 2 Arrays
    • diff --git a/d6/d25/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree__coll__graph.map b/d6/d25/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree__coll__graph.map new file mode 100644 index 000000000..58e66c36a --- /dev/null +++ b/d6/d25/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree__coll__graph.map @@ -0,0 +1,4 @@ + + + + diff --git a/d6/d25/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree__coll__graph.md5 b/d6/d25/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree__coll__graph.md5 new file mode 100644 index 000000000..e8f97ecdd --- /dev/null +++ b/d6/d25/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree__coll__graph.md5 @@ -0,0 +1 @@ +f046a293826c0e7e82f7167a53e9aaa5 \ No newline at end of file diff --git a/d6/d25/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree__coll__graph.svg b/d6/d25/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree__coll__graph.svg new file mode 100644 index 000000000..25ccee5da --- /dev/null +++ b/d6/d25/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree__coll__graph.svg @@ -0,0 +1,48 @@ + + + + + + +operations_on_datastructures::reverse_binary_tree::BinaryTree + + + +Node1 + + +operations_on_datastructures +::reverse_binary_tree::BinaryTree + + + + + +Node2 + + +operations_on_datastructures +::reverse_binary_tree::Node + + + + + +Node2->Node1 + + + root + + + +Node2->Node2 + + + left +right + + + diff --git a/d8/dfd/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node.html b/d8/dfd/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node.html new file mode 100644 index 000000000..a55660e10 --- /dev/null +++ b/d8/dfd/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node.html @@ -0,0 +1,186 @@ + + + + + + + +Algorithms_in_C++: operations_on_datastructures::reverse_binary_tree::Node Struct Reference + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ 1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +
    +Public Member Functions | +Public Attributes | +List of all members
    +
    operations_on_datastructures::reverse_binary_tree::Node Struct Reference
    +
    +
    + +

    A Node struct that represents a single node in a Binary Tree. + More...

    +
    +Collaboration diagram for operations_on_datastructures::reverse_binary_tree::Node:
    +
    +
    +
    +
    [legend]
    + + + + + +

    +Public Member Functions

     Node (int64_t _data)
     Creates a new Node with some initial data. More...
     
    + + + + + + + + + + +

    +Public Attributes

    +int64_t data
     The value of the Node.
     
    +Node * left
     The Node's left child.
     
    +Node * right
     The Node's right child.
     
    +

    Detailed Description

    +

    A Node struct that represents a single node in a Binary Tree.

    +

    Constructor & Destructor Documentation

    + +

    ◆ Node()

    + +
    +
    + + + + + +
    + + + + + + + + +
    operations_on_datastructures::reverse_binary_tree::Node::Node (int64_t _data)
    +     		+inlineexplicit
    +
    + +

    Creates a new Node with some initial data.

    +

    < Set value of Node data

    +

    < Initialize left child to NULL

    +

    < Initialize right child to NULL

    +
    41 {
    +
    42 data = _data; ///< Set value of Node data
    +
    43 left = nullptr; ///< Initialize left child to NULL
    +
    44 right = nullptr; ///< Initialize right child to NULL
    +
    45 }
    +
    operations_on_datastructures::reverse_binary_tree::Node::right
    Node * right
    The Node's right child.
    Definition: reverse_binary_tree.cpp:37
    +
    operations_on_datastructures::reverse_binary_tree::Node::data
    int64_t data
    The value of the Node.
    Definition: reverse_binary_tree.cpp:35
    +
    operations_on_datastructures::reverse_binary_tree::Node::left
    Node * left
    The Node's left child.
    Definition: reverse_binary_tree.cpp:36
    +
    +
    +
    +
    The documentation for this struct was generated from the following file: +
    +
    + + + + diff --git a/d8/dfd/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node.js b/d8/dfd/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node.js new file mode 100644 index 000000000..cd01634a9 --- /dev/null +++ b/d8/dfd/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node.js @@ -0,0 +1,7 @@ +var structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node = +[ + [ "Node", "d8/dfd/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node.html#a15dd7a0a7d9b1e8b2012c5161aecd6e3", null ], + [ "data", "d8/dfd/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node.html#ae54953a75091532303bb08d55087077f", null ], + [ "left", "d8/dfd/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node.html#aeb01a65e51df1e3bc5296cde8477c352", null ], + [ "right", "d8/dfd/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node.html#ab13a4dd92d54c11eca86edde3ef32256", null ] +]; \ No newline at end of file diff --git a/d9/df4/namespacetests.html b/d9/df4/namespacetests.html new file mode 100644 index 000000000..693345a6f --- /dev/null +++ b/d9/df4/namespacetests.html @@ -0,0 +1,271 @@ + + + + + + + +Algorithms_in_C++: tests Namespace Reference + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ 1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +
    +Functions
    +
    tests Namespace Reference
    +
    +
    + +

    Testcases to check Reversal of Binary Tree. +More...

    + + + + + + + + + + + +

    +Functions

    void test1 ()
     < Use the BinaryTree More...
     
    void test2 ()
     A Test to check an edge case (NULL root element) More...
     
    void test3 ()
     A Test to check correct reversal of a Binary Tree. More...
     
    +

    Detailed Description

    +

    Testcases to check Reversal of Binary Tree.

    +

    Function Documentation

    + +

    ◆ test1()

    + +
    +
    + + + + + + + +
    void tests::test1 ()
    +
    + +

    < Use the BinaryTree

    +

    A Test to check an edge case (single element reversal)

    +

    < Check for equal sizes

    +

    < Ensure that there is only one element

    +

    < Check if both elements are same

    +
    167 {
    +
    168 BinaryTree bst;
    +
    169 std::vector<int64_t> pre_reversal, post_reversal;
    +
    170 std::cout << "TEST CASE 1\n";
    +
    171 std::cout << "Initializing tree with a single element (5)\n";
    +
    172 bst.add(5);
    +
    173 pre_reversal = bst.get_level_order();
    +
    174 std::cout << "Before reversal: ";
    +
    175 bst.print();
    +
    176 std::cout << "After reversal: ";
    +
    177 bst.reverse();
    +
    178 post_reversal = bst.get_level_order();
    +
    179 assert(pre_reversal.size() ==
    +
    180 post_reversal.size()); ///< Check for equal sizes
    +
    181 assert(pre_reversal.size() ==
    +
    182 1); ///< Ensure that there is only one element
    +
    183 assert(pre_reversal[0] ==
    +
    184 post_reversal[0]); ///< Check if both elements are same
    +
    185 bst.print();
    +
    186 std::cout << "TEST PASSED!\n\n";
    +
    187}
    + +
    std::vector::size
    T size(T... args)
    + +
    +Here is the call graph for this function:
    +
    +
    +
    +
    + +
    +
    + +

    ◆ test2()

    + +
    +
    + + + + + + + +
    void tests::test2 ()
    +
    + +

    A Test to check an edge case (NULL root element)

    +

    < Check for equal sizes

    +

    < Ensure that there is only one element

    +
    191 {
    +
    192 BinaryTree bst;
    +
    193 std::vector<int64_t> pre_reversal, post_reversal;
    +
    194 std::cout << "TEST CASE 2\n";
    +
    195 std::cout << "Creating empty tree (root points to NULL)\n";
    +
    196 pre_reversal = bst.get_level_order();
    +
    197 std::cout << "Before reversal: ";
    +
    198 bst.print();
    +
    199 std::cout << "After reversal: ";
    +
    200 bst.reverse();
    +
    201 post_reversal = bst.get_level_order();
    +
    202 assert(pre_reversal.size() ==
    +
    203 post_reversal.size()); ///< Check for equal sizes
    +
    204 assert(pre_reversal.size() ==
    +
    205 0); ///< Ensure that there is only one element
    +
    206 bst.print();
    +
    207 std::cout << "TEST PASSED!\n\n";
    +
    208}
    +
    +Here is the call graph for this function:
    +
    +
    +
    +
    + +
    +
    + +

    ◆ test3()

    + +
    +
    + + + + + + + +
    void tests::test3 ()
    +
    + +

    A Test to check correct reversal of a Binary Tree.

    +

    < Check for equality

    +

    < Check for equality

    +
    212 {
    +
    213 BinaryTree bst;
    +
    214 std::vector<int64_t> pre_reversal, post_reversal;
    +
    215 std::vector<int64_t> pre_res = {4, 3, 6, 2, 5, 7, 1};
    +
    216 std::vector<int64_t> post_res = {4, 6, 3, 7, 5, 2, 1};
    +
    217 std::cout << "TEST CASE 3\n";
    +
    218 std::cout << "Creating tree with elements (4, 6, 3, 2, 5, 7, 1)\n";
    +
    219 bst.add(4);
    +
    220 bst.add(6);
    +
    221 bst.add(3);
    +
    222 bst.add(2);
    +
    223 bst.add(5);
    +
    224 bst.add(7);
    +
    225 bst.add(1);
    +
    226 pre_reversal = bst.get_level_order();
    +
    227 assert(pre_reversal == pre_res); ///< Check for equality
    +
    228 std::cout << "Before reversal: ";
    +
    229 bst.print();
    +
    230 std::cout << "After reversal: ";
    +
    231 bst.reverse();
    +
    232 post_reversal = bst.get_level_order();
    +
    233 assert(post_reversal == post_res); ///< Check for equality
    +
    234 bst.print();
    +
    235 std::cout << "TEST PASSED!\n\n";
    +
    236}
    +
    +
    +
    +
    +
    + + + + diff --git a/d9/df4/namespacetests_a167c24bd817469ae47358d12e034f2d5_cgraph.map b/d9/df4/namespacetests_a167c24bd817469ae47358d12e034f2d5_cgraph.map new file mode 100644 index 000000000..d1bdd52b3 --- /dev/null +++ b/d9/df4/namespacetests_a167c24bd817469ae47358d12e034f2d5_cgraph.map @@ -0,0 +1,4 @@ + + + + diff --git a/d9/df4/namespacetests_a167c24bd817469ae47358d12e034f2d5_cgraph.md5 b/d9/df4/namespacetests_a167c24bd817469ae47358d12e034f2d5_cgraph.md5 new file mode 100644 index 000000000..04e7bce1e --- /dev/null +++ b/d9/df4/namespacetests_a167c24bd817469ae47358d12e034f2d5_cgraph.md5 @@ -0,0 +1 @@ +1344df6d0aeab8af5383cc653b7cfb97 \ No newline at end of file diff --git a/d9/df4/namespacetests_a167c24bd817469ae47358d12e034f2d5_cgraph.svg b/d9/df4/namespacetests_a167c24bd817469ae47358d12e034f2d5_cgraph.svg new file mode 100644 index 000000000..72a413fac --- /dev/null +++ b/d9/df4/namespacetests_a167c24bd817469ae47358d12e034f2d5_cgraph.svg @@ -0,0 +1,37 @@ + + + + + + +tests::test1 + + + +Node1 + + +tests::test1 + + + + + +Node2 + + +std::vector::size + + + + + +Node1->Node2 + + + + + diff --git a/d9/df4/namespacetests_abdd77344d4af8fd56d14a5cabbf2f669_cgraph.map b/d9/df4/namespacetests_abdd77344d4af8fd56d14a5cabbf2f669_cgraph.map new file mode 100644 index 000000000..040bbcb24 --- /dev/null +++ b/d9/df4/namespacetests_abdd77344d4af8fd56d14a5cabbf2f669_cgraph.map @@ -0,0 +1,4 @@ + + + + diff --git a/d9/df4/namespacetests_abdd77344d4af8fd56d14a5cabbf2f669_cgraph.md5 b/d9/df4/namespacetests_abdd77344d4af8fd56d14a5cabbf2f669_cgraph.md5 new file mode 100644 index 000000000..b2f01cb72 --- /dev/null +++ b/d9/df4/namespacetests_abdd77344d4af8fd56d14a5cabbf2f669_cgraph.md5 @@ -0,0 +1 @@ +a1bc1bd2103fafa5884d976aee652897 \ No newline at end of file diff --git a/d9/df4/namespacetests_abdd77344d4af8fd56d14a5cabbf2f669_cgraph.svg b/d9/df4/namespacetests_abdd77344d4af8fd56d14a5cabbf2f669_cgraph.svg new file mode 100644 index 000000000..3efbc96a1 --- /dev/null +++ b/d9/df4/namespacetests_abdd77344d4af8fd56d14a5cabbf2f669_cgraph.svg @@ -0,0 +1,37 @@ + + + + + + +tests::test2 + + + +Node1 + + +tests::test2 + + + + + +Node2 + + +std::vector::size + + + + + +Node1->Node2 + + + + + diff --git a/da/d6d/namespaceoperations__on__datastructures.html b/da/d6d/namespaceoperations__on__datastructures.html index 287f17d44..0da573276 100644 --- a/da/d6d/namespaceoperations__on__datastructures.html +++ b/da/d6d/namespaceoperations__on__datastructures.html @@ -99,8 +99,11 @@ $(document).ready(function(){initNavTree('da/d6d/namespaceoperations__on__datast

    Detailed Description

    for std::vector

    for std::priority_queue

    +

    For std::vector.

    for assert for IO Operations

    Operations on data structures

    +

    For assert For IO operations For std::queue

    +

    Operations on Data Structures

    for std::count for assert for tolower for string operations for IO Operations

    Operations on data structures

    diff --git a/da/d6d/namespaceoperations__on__datastructures.js b/da/d6d/namespaceoperations__on__datastructures.js index aa731ea48..e256ba2d3 100644 --- a/da/d6d/namespaceoperations__on__datastructures.js +++ b/da/d6d/namespaceoperations__on__datastructures.js @@ -11,6 +11,10 @@ var namespaceoperations__on__datastructures = [ "makeNode", "d4/d32/inorder__successor__of__bst_8cpp.html#a7f6f73a33beec448c27cc1d70b220702", null ], [ "printInorder", "d4/d32/inorder__successor__of__bst_8cpp.html#a5d7266b934ca50c4f53e4f1e725d89a4", null ] ] ], + [ "reverse_binary_tree", null, [ + [ "BinaryTree", "de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree.html", "de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree" ], + [ "Node", "d8/dfd/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node.html", "d8/dfd/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node" ] + ] ], [ "trie_operations", null, [ [ "Tnode", "d0/d5f/classoperations__on__datastructures_1_1trie__operations_1_1_tnode.html", "d0/d5f/classoperations__on__datastructures_1_1trie__operations_1_1_tnode" ] ] ] diff --git a/db/da0/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node__coll__graph.map b/db/da0/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node__coll__graph.map new file mode 100644 index 000000000..7e7dc6702 --- /dev/null +++ b/db/da0/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node__coll__graph.map @@ -0,0 +1,3 @@ + + + diff --git a/db/da0/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node__coll__graph.md5 b/db/da0/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node__coll__graph.md5 new file mode 100644 index 000000000..75500c561 --- /dev/null +++ b/db/da0/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node__coll__graph.md5 @@ -0,0 +1 @@ +bfa4995b3a84cf585b0534e0fbd90ca9 \ No newline at end of file diff --git a/db/da0/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node__coll__graph.svg b/db/da0/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node__coll__graph.svg new file mode 100644 index 000000000..ecd9a1f2f --- /dev/null +++ b/db/da0/structoperations__on__datastructures_1_1reverse__binary__tree_1_1_node__coll__graph.svg @@ -0,0 +1,31 @@ + + + + + + +operations_on_datastructures::reverse_binary_tree::Node + + + +Node1 + + +operations_on_datastructures +::reverse_binary_tree::Node + + + + + +Node1->Node1 + + + left +right + + + diff --git a/db/de3/reverse__binary__tree_8cpp__incl.map b/db/de3/reverse__binary__tree_8cpp__incl.map new file mode 100644 index 000000000..4b68ba342 --- /dev/null +++ b/db/de3/reverse__binary__tree_8cpp__incl.map @@ -0,0 +1,7 @@ + + + + + + + diff --git a/db/de3/reverse__binary__tree_8cpp__incl.md5 b/db/de3/reverse__binary__tree_8cpp__incl.md5 new file mode 100644 index 000000000..01c1ae896 --- /dev/null +++ b/db/de3/reverse__binary__tree_8cpp__incl.md5 @@ -0,0 +1 @@ +00563001af3cac291d944ae12b653fb0 \ No newline at end of file diff --git a/db/de3/reverse__binary__tree_8cpp__incl.svg b/db/de3/reverse__binary__tree_8cpp__incl.svg new file mode 100644 index 000000000..a83175807 --- /dev/null +++ b/db/de3/reverse__binary__tree_8cpp__incl.svg @@ -0,0 +1,83 @@ + + + + + + +operations_on_datastructures/reverse_binary_tree.cpp + + + +Node1 + + +operations_on_datastructures +/reverse_binary_tree.cpp + + + + + +Node2 + + +cassert + + + + + +Node1->Node2 + + + + + +Node3 + + +iostream + + + + + +Node1->Node3 + + + + + +Node4 + + +queue + + + + + +Node1->Node4 + + + + + +Node5 + + +vector + + + + + +Node1->Node5 + + + + + diff --git a/dc/dc5/namespacereverse__binary__tree.html b/dc/dc5/namespacereverse__binary__tree.html new file mode 100644 index 000000000..6c9f58589 --- /dev/null +++ b/dc/dc5/namespacereverse__binary__tree.html @@ -0,0 +1,111 @@ + + + + + + + +Algorithms_in_C++: reverse_binary_tree Namespace Reference + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ 1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +
    reverse_binary_tree Namespace Reference
    +
    +
    + +

    Functions for the Reverse a Binary Tree implementation. +More...

    +

    Detailed Description

    +

    Functions for the Reverse a Binary Tree implementation.

    +
    +
    + + + + diff --git a/dd/d03/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree-members.html b/dd/d03/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree-members.html new file mode 100644 index 000000000..5d7a2c8ec --- /dev/null +++ b/dd/d03/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree-members.html @@ -0,0 +1,117 @@ + + + + + + + +Algorithms_in_C++: Member List + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ 1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +
    operations_on_datastructures::reverse_binary_tree::BinaryTree Member List
    +
    +
    + +

    This is the complete list of members for operations_on_datastructures::reverse_binary_tree::BinaryTree, including all inherited members.

    + + + + + + + + + + +
    add(int64_t data)operations_on_datastructures::reverse_binary_tree::BinaryTreeinline
    BinaryTree()operations_on_datastructures::reverse_binary_tree::BinaryTreeinline
    BinaryTree(int64_t data)operations_on_datastructures::reverse_binary_tree::BinaryTreeinlineexplicit
    get_level_order()operations_on_datastructures::reverse_binary_tree::BinaryTreeinline
    insert(int64_t data, Node *pivot)operations_on_datastructures::reverse_binary_tree::BinaryTreeinlineprivate
    print()operations_on_datastructures::reverse_binary_tree::BinaryTreeinline
    reverse()operations_on_datastructures::reverse_binary_tree::BinaryTreeinline
    reverseBinaryTree(Node *pivot)operations_on_datastructures::reverse_binary_tree::BinaryTreeinlineprivate
    rootoperations_on_datastructures::reverse_binary_tree::BinaryTreeprivate
    +
    + + + + diff --git a/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree.html b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree.html new file mode 100644 index 000000000..bb59037c9 --- /dev/null +++ b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree.html @@ -0,0 +1,530 @@ + + + + + + + +Algorithms_in_C++: operations_on_datastructures::reverse_binary_tree::BinaryTree Class Reference + + + + + + + + + + + + + + + +
    +
    + + + + + + +
    +
    Algorithms_in_C++ 1.0.0 +
    +
    Set of algorithms implemented in C++.
    +
    +
    + + + + + + + +
    +
    + +
    +
    +
    + +
    + +
    +
    + + +
    + +
    + +
    +
    +Public Member Functions | +Private Member Functions | +Private Attributes | +List of all members
    +
    operations_on_datastructures::reverse_binary_tree::BinaryTree Class Reference
    +
    +
    + +

    A Binary Tree class that implements a Binary Search Tree (BST) by default. + More...

    +
    +Collaboration diagram for operations_on_datastructures::reverse_binary_tree::BinaryTree:
    +
    +
    +
    +
    [legend]
    + + + + + + + + + + + + + + + + + + + +

    +Public Member Functions

     BinaryTree ()
     Creates a BinaryTree with a root pointing to NULL. More...
     
     BinaryTree (int64_t data)
     Creates a BinaryTree with a root with an initial value. More...
     
    void add (int64_t data)
     Adds a new Node to the Binary Tree. More...
     
    void reverse ()
     
    std::vector< int64_t > get_level_order ()
     Level order traversal of a tree consists of visiting its elements, top to bottom, left to right. This function performs level order traversal and returns the node datas as a vector. More...
     
    void print ()
     Prints all of the elements in the tree to stdout level-by-level, using the get_level_order() function. More...
     
    + + + + + + + +

    +Private Member Functions

    Node * insert (int64_t data, Node *pivot)
     inserts a node in the Binary Tree, with the behaviouur of a Binary Search Tree. More...
     
    Node * reverseBinaryTree (Node *pivot)
     Reverses a Binary Tree recursively by swapping the left and right subtrees and their children. More...
     
    + + + + +

    +Private Attributes

    +Node * root
     Pointer to root node of Binary Tree.
     
    +

    Detailed Description

    +

    A Binary Tree class that implements a Binary Search Tree (BST) by default.

    +

    Constructor & Destructor Documentation

    + +

    ◆ BinaryTree() [1/2]

    + +
    +
    + + + + + +
    + + + + + + + +
    operations_on_datastructures::reverse_binary_tree::BinaryTree::BinaryTree ()
    +     		+inline
    +
    + +

    Creates a BinaryTree with a root pointing to NULL.

    +
    98{ root = nullptr; }
    +
    operations_on_datastructures::reverse_binary_tree::BinaryTree::root
    Node * root
    Pointer to root node of Binary Tree.
    Definition: reverse_binary_tree.cpp:54
    +
    +
    +
    + +

    ◆ BinaryTree() [2/2]

    + +
    +
    + + + + + +
    + + + + + + + + +
    operations_on_datastructures::reverse_binary_tree::BinaryTree::BinaryTree (int64_t data)
    +     		+inlineexplicit
    +
    + +

    Creates a BinaryTree with a root with an initial value.

    +
    102{ root = new Node(data); }
    +
    data
    int data[MAX]
    test data
    Definition: hash_search.cpp:24
    +
    Node
    Definition: linkedlist_implentation_usingarray.cpp:14
    +
    +
    +
    +

    Member Function Documentation

    + +

    ◆ add()

    + +
    +
    + + + + + +
    + + + + + + + + +
    void operations_on_datastructures::reverse_binary_tree::BinaryTree::add (int64_t data)
    +     		+inline
    +
    + +

    Adds a new Node to the Binary Tree.

    +
    106{ root = insert(data, root); }
    +
    operations_on_datastructures::reverse_binary_tree::BinaryTree::insert
    Node * insert(int64_t data, Node *pivot)
    inserts a node in the Binary Tree, with the behaviouur of a Binary Search Tree.
    Definition: reverse_binary_tree.cpp:65
    +
    +Here is the call graph for this function:
    +
    +
    +
    +
    + +
    +
    + +

    ◆ get_level_order()

    + +
    +
    + + + + + +
    + + + + + + + +
    std::vector< int64_t > operations_on_datastructures::reverse_binary_tree::BinaryTree::get_level_order ()
    +     		+inline
    +
    + +

    Level order traversal of a tree consists of visiting its elements, top to bottom, left to right. This function performs level order traversal and returns the node datas as a vector.

    +

    The function uses a queue to append and remove elements as they are visited, and then adds their children, if any. This ensures that the elements are visited layer-by-layer, starting from the root of the Tree.

    Returns
    vector<int64_t> of nodes of the tree.
    +

    < Result vector of int

    +

    < Return empty vector if root is Invalid

    +

    < Queue of the nodes in the tree

    +

    < Insert root into the queue

    +

    < Copy the first element

    +

    < Add the element to the data

    +

    < Remove element

    +

    < Insert left node

    +

    < Insert right node

    +

    Add nodes while Tree is not empty

    +
    121 {
    +
    122 std::vector<int64_t> data; ///< Result vector of int
    +
    123 if (root == nullptr) {
    +
    124 return data; ///< Return empty vector if root is Invalid
    +
    125 }
    +
    126 std::queue<Node*> nodes; ///< Queue of the nodes in the tree
    +
    127 nodes.push(root); ///< Insert root into the queue
    +
    128 while (!nodes.empty()) {
    +
    129 Node* temp = nodes.front(); ///< Copy the first element
    +
    130 data.push_back(temp->data); ///< Add the element to the data
    +
    131 nodes.pop(); ///< Remove element
    +
    132 if (temp->left != nullptr) {
    +
    133 nodes.push(temp->left); ///< Insert left node
    +
    134 }
    +
    135 if (temp->right != nullptr) {
    +
    136 nodes.push(temp->right); ///< Insert right node
    +
    137 }
    +
    138 } /// Add nodes while Tree is not empty
    +
    139 return data;
    +
    140 }
    +
    std::queue::empty
    T empty(T... args)
    +
    std::queue::front
    T front(T... args)
    +
    std::queue::pop
    T pop(T... args)
    +
    std::queue::push
    T push(T... args)
    + + +
    +Here is the call graph for this function:
    +
    +
    +
    +
    + +
    +
    + +

    ◆ insert()

    + +
    +
    + + + + + +
    + + + + + + + + + + + + + + + + + + +
    Node * operations_on_datastructures::reverse_binary_tree::BinaryTree::insert (int64_t data,
    Node * pivot 
    )
    +     		+inlineprivate
    +
    + +

    inserts a node in the Binary Tree, with the behaviouur of a Binary Search Tree.

    +

    Nodes with smaller values are inserted in the left subtree, and Nodes with larger values are inserted into the right subtree recursively. Time Complexity: O(log(n))

    Parameters
    + + + +
    dataThe data/value of the Node to be inserted
    pivotA pointer to the root node of the (sub)tree
    +
    +
    +
    Returns
    Node pointer to the root
    +

    < Create new node

    +

    < Insert Node to the left

    +

    < Insert node to the right

    +
    65 {
    +
    66 if (pivot == nullptr) {
    +
    67 return new Node(data); ///< Create new node
    +
    68 }
    +
    69 if (data <= pivot->data) {
    +
    70 pivot->left =
    +
    71 insert(data, pivot->left); ///< Insert Node to the left
    +
    72 } else {
    +
    73 pivot->right =
    +
    74 insert(data, pivot->right); ///< Insert node to the right
    +
    75 }
    +
    76 return pivot;
    +
    77 }
    +
    +Here is the call graph for this function:
    +
    +
    +
    +
    + +
    +
    + +

    ◆ print()

    + +
    +
    + + + + + +
    + + + + + + + +
    void operations_on_datastructures::reverse_binary_tree::BinaryTree::print ()
    +     		+inline
    +
    + +

    Prints all of the elements in the tree to stdout level-by-level, using the get_level_order() function.

    +
    Returns
    void
    +

    Print each element in the tree

    +

    Print newline

    +
    146 {
    +
    147 for (int i : get_level_order()) {
    +
    148 std::cout << i << " "; /// Print each element in the tree
    +
    149 }
    +
    150 std::cout << "\n"; /// Print newline
    +
    151 }
    + +
    operations_on_datastructures::reverse_binary_tree::BinaryTree::get_level_order
    std::vector< int64_t > get_level_order()
    Level order traversal of a tree consists of visiting its elements, top to bottom, left to right....
    Definition: reverse_binary_tree.cpp:121
    +
    +Here is the call graph for this function:
    +
    +
    +
    +
    + +
    +
    + +

    ◆ reverse()

    + +
    +
    + + + + + +
    + + + + + + + +
    void operations_on_datastructures::reverse_binary_tree::BinaryTree::reverse ()
    +     		+inline
    +
    +

    Reverses the Binary Tree

    +
    110{ root = reverseBinaryTree(root); }
    +
    operations_on_datastructures::reverse_binary_tree::BinaryTree::reverseBinaryTree
    Node * reverseBinaryTree(Node *pivot)
    Reverses a Binary Tree recursively by swapping the left and right subtrees and their children.
    Definition: reverse_binary_tree.cpp:84
    +
    +Here is the call graph for this function:
    +
    +
    +
    +
    + +
    +
    + +

    ◆ reverseBinaryTree()

    + +
    +
    + + + + + +
    + + + + + + + + +
    Node * operations_on_datastructures::reverse_binary_tree::BinaryTree::reverseBinaryTree (Node * pivot)
    +     		+inlineprivate
    +
    + +

    Reverses a Binary Tree recursively by swapping the left and right subtrees and their children.

    +
    Parameters
    + + +
    pivotA reference to the root of the (sub)tree
    +
    +
    +
    Returns
    Node pointer to root node
    +

    < Base case

    +

    < pointer to the left subtree

    +

    < Swap

    +

    < Swap

    +
    84 {
    +
    85 if (pivot == nullptr) {
    +
    86 return pivot; ///< Base case
    +
    87 }
    +
    88 Node* temp = pivot->left; ///< pointer to the left subtree
    +
    89 pivot->left = reverseBinaryTree(pivot->right); ///< Swap
    +
    90 pivot->right = reverseBinaryTree(temp); ///< Swap
    +
    91 return pivot;
    +
    92 }
    +
    +Here is the call graph for this function:
    +
    +
    +
    +
    + +
    +
    +
    The documentation for this class was generated from the following file: +
    +
    + + + + diff --git a/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree.js b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree.js new file mode 100644 index 000000000..a75695afe --- /dev/null +++ b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree.js @@ -0,0 +1,12 @@ +var classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree = +[ + [ "BinaryTree", "de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree.html#abcb1cc8da7b6759dc92cbe0254697c56", null ], + [ "BinaryTree", "de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree.html#abb44646a26a446efae7704c80efc011b", null ], + [ "add", "de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree.html#a534645d1aabdf1a7e5897c85376f173d", null ], + [ "get_level_order", "de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree.html#a2e683b271d8d5cd63e0d09cf8aaa325c", null ], + [ "insert", "de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree.html#adb2b6be741b0500ee75d89b6d06b5d50", null ], + [ "print", "de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree.html#a5cf972a2c994a4fa1a89fc77bd5ad503", null ], + [ "reverse", "de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree.html#a1c0d27198372b36ef71bc58af8336b9c", null ], + [ "reverseBinaryTree", "de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree.html#af6f974381f523fdb981fc2d843bbf4a1", null ], + [ "root", "de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree.html#ab6a17a04aa93aaaef71e038e8cc2edeb", null ] +]; \ No newline at end of file diff --git a/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a1c0d27198372b36ef71bc58af8336b9c_cgraph.map b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a1c0d27198372b36ef71bc58af8336b9c_cgraph.map new file mode 100644 index 000000000..500c45700 --- /dev/null +++ b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a1c0d27198372b36ef71bc58af8336b9c_cgraph.map @@ -0,0 +1,4 @@ + + + + diff --git a/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a1c0d27198372b36ef71bc58af8336b9c_cgraph.md5 b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a1c0d27198372b36ef71bc58af8336b9c_cgraph.md5 new file mode 100644 index 000000000..8c8ea6452 --- /dev/null +++ b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a1c0d27198372b36ef71bc58af8336b9c_cgraph.md5 @@ -0,0 +1 @@ +fab6989ed4aca33dbeba9e25d33748b7 \ No newline at end of file diff --git a/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a1c0d27198372b36ef71bc58af8336b9c_cgraph.svg b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a1c0d27198372b36ef71bc58af8336b9c_cgraph.svg new file mode 100644 index 000000000..2b039e934 --- /dev/null +++ b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a1c0d27198372b36ef71bc58af8336b9c_cgraph.svg @@ -0,0 +1,47 @@ + + + + + + +operations_on_datastructures::reverse_binary_tree::BinaryTree::reverse + + + +Node1 + + +operations_on_datastructures +::reverse_binary_tree::BinaryTree +::reverse + + + + + +Node2 + + +operations_on_datastructures +::reverse_binary_tree::BinaryTree +::reverseBinaryTree + + + + + +Node1->Node2 + + + + + +Node2->Node2 + + + + + diff --git a/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a2e683b271d8d5cd63e0d09cf8aaa325c_cgraph.map b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a2e683b271d8d5cd63e0d09cf8aaa325c_cgraph.map new file mode 100644 index 000000000..377a3912c --- /dev/null +++ b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a2e683b271d8d5cd63e0d09cf8aaa325c_cgraph.map @@ -0,0 +1,7 @@ + + + + + + + diff --git a/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a2e683b271d8d5cd63e0d09cf8aaa325c_cgraph.md5 b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a2e683b271d8d5cd63e0d09cf8aaa325c_cgraph.md5 new file mode 100644 index 000000000..98d6f3165 --- /dev/null +++ b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a2e683b271d8d5cd63e0d09cf8aaa325c_cgraph.md5 @@ -0,0 +1 @@ +ae02f7775c41448df6f9437622aed740 \ No newline at end of file diff --git a/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a2e683b271d8d5cd63e0d09cf8aaa325c_cgraph.svg b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a2e683b271d8d5cd63e0d09cf8aaa325c_cgraph.svg new file mode 100644 index 000000000..e6ad6590b --- /dev/null +++ b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a2e683b271d8d5cd63e0d09cf8aaa325c_cgraph.svg @@ -0,0 +1,84 @@ + + + + + + +operations_on_datastructures::reverse_binary_tree::BinaryTree::get_level_order + + + +Node1 + + +operations_on_datastructures +::reverse_binary_tree::BinaryTree +::get_level_order + + + + + +Node2 + + +std::queue::empty + + + + + +Node1->Node2 + + + + + +Node3 + + +std::queue::front + + + + + +Node1->Node3 + + + + + +Node4 + + +std::queue::pop + + + + + +Node1->Node4 + + + + + +Node5 + + +std::queue::push + + + + + +Node1->Node5 + + + + + diff --git a/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a534645d1aabdf1a7e5897c85376f173d_cgraph.map b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a534645d1aabdf1a7e5897c85376f173d_cgraph.map new file mode 100644 index 000000000..5602bbdd2 --- /dev/null +++ b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a534645d1aabdf1a7e5897c85376f173d_cgraph.map @@ -0,0 +1,4 @@ + + + + diff --git a/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a534645d1aabdf1a7e5897c85376f173d_cgraph.md5 b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a534645d1aabdf1a7e5897c85376f173d_cgraph.md5 new file mode 100644 index 000000000..12b5932f6 --- /dev/null +++ b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a534645d1aabdf1a7e5897c85376f173d_cgraph.md5 @@ -0,0 +1 @@ +518877f8eaff608e0ec54eb4cac22b14 \ No newline at end of file diff --git a/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a534645d1aabdf1a7e5897c85376f173d_cgraph.svg b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a534645d1aabdf1a7e5897c85376f173d_cgraph.svg new file mode 100644 index 000000000..ef2c76714 --- /dev/null +++ b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a534645d1aabdf1a7e5897c85376f173d_cgraph.svg @@ -0,0 +1,46 @@ + + + + + + +operations_on_datastructures::reverse_binary_tree::BinaryTree::add + + + +Node1 + + +operations_on_datastructures +::reverse_binary_tree::BinaryTree::add + + + + + +Node2 + + +operations_on_datastructures +::reverse_binary_tree::BinaryTree +::insert + + + + + +Node1->Node2 + + + + + +Node2->Node2 + + + + + diff --git a/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a5cf972a2c994a4fa1a89fc77bd5ad503_cgraph.map b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a5cf972a2c994a4fa1a89fc77bd5ad503_cgraph.map new file mode 100644 index 000000000..782cb1966 --- /dev/null +++ b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a5cf972a2c994a4fa1a89fc77bd5ad503_cgraph.map @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a5cf972a2c994a4fa1a89fc77bd5ad503_cgraph.md5 b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a5cf972a2c994a4fa1a89fc77bd5ad503_cgraph.md5 new file mode 100644 index 000000000..502c228e9 --- /dev/null +++ b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a5cf972a2c994a4fa1a89fc77bd5ad503_cgraph.md5 @@ -0,0 +1 @@ +fd637765a68b228122fe78d8fbc73ac6 \ No newline at end of file diff --git a/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a5cf972a2c994a4fa1a89fc77bd5ad503_cgraph.svg b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a5cf972a2c994a4fa1a89fc77bd5ad503_cgraph.svg new file mode 100644 index 000000000..2b48a4ec1 --- /dev/null +++ b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a5cf972a2c994a4fa1a89fc77bd5ad503_cgraph.svg @@ -0,0 +1,188 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +operations_on_datastructures::reverse_binary_tree::BinaryTree::print + + + +Node1 + + +operations_on_datastructures +::reverse_binary_tree::BinaryTree::print + + + + + +Node2 + + +operations_on_datastructures +::reverse_binary_tree::BinaryTree +::get_level_order + + + + + +Node1->Node2 + + + + + +Node3 + + +std::queue::empty + + + + + +Node2->Node3 + + + + + +Node4 + + +std::queue::front + + + + + +Node2->Node4 + + + + + +Node5 + + +std::queue::pop + + + + + +Node2->Node5 + + + + + +Node6 + + +std::queue::push + + + + + +Node2->Node6 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a5cf972a2c994a4fa1a89fc77bd5ad503_cgraph_org.svg b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a5cf972a2c994a4fa1a89fc77bd5ad503_cgraph_org.svg new file mode 100644 index 000000000..39b170606 --- /dev/null +++ b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_a5cf972a2c994a4fa1a89fc77bd5ad503_cgraph_org.svg @@ -0,0 +1,100 @@ + + + + + + +operations_on_datastructures::reverse_binary_tree::BinaryTree::print + + + +Node1 + + +operations_on_datastructures +::reverse_binary_tree::BinaryTree::print + + + + + +Node2 + + +operations_on_datastructures +::reverse_binary_tree::BinaryTree +::get_level_order + + + + + +Node1->Node2 + + + + + +Node3 + + +std::queue::empty + + + + + +Node2->Node3 + + + + + +Node4 + + +std::queue::front + + + + + +Node2->Node4 + + + + + +Node5 + + +std::queue::pop + + + + + +Node2->Node5 + + + + + +Node6 + + +std::queue::push + + + + + +Node2->Node6 + + + + + diff --git a/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_adb2b6be741b0500ee75d89b6d06b5d50_cgraph.map b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_adb2b6be741b0500ee75d89b6d06b5d50_cgraph.map new file mode 100644 index 000000000..f6019a045 --- /dev/null +++ b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_adb2b6be741b0500ee75d89b6d06b5d50_cgraph.map @@ -0,0 +1,3 @@ + + + diff --git a/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_adb2b6be741b0500ee75d89b6d06b5d50_cgraph.md5 b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_adb2b6be741b0500ee75d89b6d06b5d50_cgraph.md5 new file mode 100644 index 000000000..a0854e0b4 --- /dev/null +++ b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_adb2b6be741b0500ee75d89b6d06b5d50_cgraph.md5 @@ -0,0 +1 @@ +50215a131e5000465ebfdeb73ed12356 \ No newline at end of file diff --git a/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_adb2b6be741b0500ee75d89b6d06b5d50_cgraph.svg b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_adb2b6be741b0500ee75d89b6d06b5d50_cgraph.svg new file mode 100644 index 000000000..ba3385bb2 --- /dev/null +++ b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_adb2b6be741b0500ee75d89b6d06b5d50_cgraph.svg @@ -0,0 +1,30 @@ + + + + + + +operations_on_datastructures::reverse_binary_tree::BinaryTree::insert + + + +Node1 + + +operations_on_datastructures +::reverse_binary_tree::BinaryTree +::insert + + + + + +Node1->Node1 + + + + + diff --git a/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_af6f974381f523fdb981fc2d843bbf4a1_cgraph.map b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_af6f974381f523fdb981fc2d843bbf4a1_cgraph.map new file mode 100644 index 000000000..fd7a7d900 --- /dev/null +++ b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_af6f974381f523fdb981fc2d843bbf4a1_cgraph.map @@ -0,0 +1,3 @@ + + + diff --git a/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_af6f974381f523fdb981fc2d843bbf4a1_cgraph.md5 b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_af6f974381f523fdb981fc2d843bbf4a1_cgraph.md5 new file mode 100644 index 000000000..0464004f8 --- /dev/null +++ b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_af6f974381f523fdb981fc2d843bbf4a1_cgraph.md5 @@ -0,0 +1 @@ +6d02190cc26eae1e67f73edf78f916a0 \ No newline at end of file diff --git a/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_af6f974381f523fdb981fc2d843bbf4a1_cgraph.svg b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_af6f974381f523fdb981fc2d843bbf4a1_cgraph.svg new file mode 100644 index 000000000..087fd664c --- /dev/null +++ b/de/dcf/classoperations__on__datastructures_1_1reverse__binary__tree_1_1_binary_tree_af6f974381f523fdb981fc2d843bbf4a1_cgraph.svg @@ -0,0 +1,30 @@ + + + + + + +operations_on_datastructures::reverse_binary_tree::BinaryTree::reverseBinaryTree + + + +Node1 + + +operations_on_datastructures +::reverse_binary_tree::BinaryTree +::reverseBinaryTree + + + + + +Node1->Node1 + + + + + diff --git a/dir_35422be6552f1b3672c1b6c4aba2da64.html b/dir_35422be6552f1b3672c1b6c4aba2da64.html index 85a0093d3..62aad1619 100644 --- a/dir_35422be6552f1b3672c1b6c4aba2da64.html +++ b/dir_35422be6552f1b3672c1b6c4aba2da64.html @@ -99,6 +99,9 @@ Files file  inorder_successor_of_bst.cpp  An implementation for finding the Inorder successor of a binary search tree Inorder successor of a node is the next node in Inorder traversal of the Binary Tree. Inorder Successor is NULL for the last node in Inorder traversal.
      +file  reverse_binary_tree.cpp + Implementation for the Reversing a Binary Tree recursively algorithm.
    +  file  trie_multiple_search.cpp  Trie datastructure with search variants
      diff --git a/dir_35422be6552f1b3672c1b6c4aba2da64.js b/dir_35422be6552f1b3672c1b6c4aba2da64.js index 109c89eb2..2d45520f9 100644 --- a/dir_35422be6552f1b3672c1b6c4aba2da64.js +++ b/dir_35422be6552f1b3672c1b6c4aba2da64.js @@ -1,5 +1,6 @@ var dir_35422be6552f1b3672c1b6c4aba2da64 = [ [ "inorder_successor_of_bst.cpp", "d4/d32/inorder__successor__of__bst_8cpp.html", "d4/d32/inorder__successor__of__bst_8cpp" ], + [ "reverse_binary_tree.cpp", "d4/db6/reverse__binary__tree_8cpp.html", "d4/db6/reverse__binary__tree_8cpp" ], [ "trie_multiple_search.cpp", "d7/def/trie__multiple__search_8cpp.html", "d7/def/trie__multiple__search_8cpp" ] ]; \ No newline at end of file diff --git a/files.html b/files.html index 18ce5a649..01c57eb65 100644 --- a/files.html +++ b/files.html @@ -268,7 +268,8 @@ solve-a-rat-in-a-maze-c-java-pytho/"  successive_approximation.cppMethod of successive approximations using fixed-point iteration method  ► operations_on_datastructures  inorder_successor_of_bst.cppAn implementation for finding the Inorder successor of a binary search tree Inorder successor of a node is the next node in Inorder traversal of the Binary Tree. Inorder Successor is NULL for the last node in Inorder traversal - trie_multiple_search.cppTrie datastructure with search variants + reverse_binary_tree.cppImplementation for the Reversing a Binary Tree recursively algorithm + trie_multiple_search.cppTrie datastructure with search variants  ► others  buzz_number.cppA buzz number is a number that is either divisible by 7 or has last digit as 7  decimal_to_binary.cppFunction to convert decimal number to binary representation diff --git a/functions_a.html b/functions_a.html index 87a21dfba..b5c877963 100644 --- a/functions_a.html +++ b/functions_a.html @@ -99,7 +99,7 @@ $(document).ready(function(){initNavTree('functions_a.html',''); initResizable()
  • accuracy : machine_learning::adaline
  • activation() : machine_learning::adaline
  • adaline() : machine_learning::adaline
    • -
  • add() : hash_chain
    • +
  • add() : hash_chain, operations_on_datastructures::reverse_binary_tree::BinaryTree
  • add_digit() : large_number
  • add_edge() : graph::Graph< T >, range_queries::heavy_light_decomposition::Tree< X >
  • addEdge() : Graph, graph::HKGraph, graph::is_graph_bipartite::Graph
    • diff --git a/functions_b.html b/functions_b.html index 67928b2bf..62123bf06 100644 --- a/functions_b.html +++ b/functions_b.html @@ -97,6 +97,7 @@ $(document).ready(function(){initNavTree('functions_b.html',''); initResizable()
  • bfs() : graph::HKGraph
  • binary_search_tree() : binary_search_tree< T >
  • BinarySearch() : data_structures::list_array::list
    • +
  • BinaryTree() : operations_on_datastructures::reverse_binary_tree::BinaryTree
  • breadth_first_search() : graph::Graph< T >
  • bst_node() : binary_search_tree< T >::bst_node
    • diff --git a/functions_d.html b/functions_d.html index 8c5496318..c55af58d9 100644 --- a/functions_d.html +++ b/functions_d.html @@ -93,7 +93,7 @@ $(document).ready(function(){initNavTree('functions_d.html',''); initResizable()
    Here is a list of all documented class members with links to the class documentation for each member:

    - d -

    diff --git a/functions_func_g.html b/functions_func_g.html index 7af36a993..f756722fb 100644 --- a/functions_func_g.html +++ b/functions_func_g.html @@ -108,6 +108,7 @@ $(document).ready(function(){initNavTree('functions_func_g.html',''); initResiza
  • get_elements_preorder() : binary_search_tree< T >
  • get_idx_char() : ciphers::HillCipher
  • get_inverse() : ciphers::HillCipher
    • +
  • get_level_order() : operations_on_datastructures::reverse_binary_tree::BinaryTree
  • get_size() : machine_learning::aystar_search::EightPuzzle< N >
  • get_state() : machine_learning::aystar_search::EightPuzzle< N >
  • get_XY_from_csv() : machine_learning::neural_network::NeuralNetwork
    • diff --git a/functions_func_i.html b/functions_func_i.html index b46256971..d88beb298 100644 --- a/functions_func_i.html +++ b/functions_func_i.html @@ -99,8 +99,8 @@ $(document).ready(function(){initNavTree('functions_func_i.html',''); initResiza
  • init() : range_queries::heavy_light_decomposition::HLD< X >, range_queries::heavy_light_decomposition::Tree< X >
  • inOrderIterative() : others::iterative_tree_traversals::BinaryTree
  • insert() : binary_search_tree< T >, data_structures::linked_list::list, data_structures::list_array::list
    • -
  • Insert() : data_structures::tree_234::Tree234
    • -
  • insert() : data_structures::trie, data_structures::trie_using_hashmap::Trie
    • +
  • Insert() : data_structures::tree_234::Tree234
    • +
  • insert() : data_structures::trie, data_structures::trie_using_hashmap::Trie, operations_on_datastructures::reverse_binary_tree::BinaryTree
  • Insert() : operations_on_datastructures::trie_operations::Tnode
  • insert() : probability::windowed_median::WindowedMedian, Trie
  • insertElement() : data_structures::SkipList
    • diff --git a/functions_func_n.html b/functions_func_n.html index e379fa4cf..2bfc01781 100644 --- a/functions_func_n.html +++ b/functions_func_n.html @@ -98,7 +98,7 @@ $(document).ready(function(){initNavTree('functions_func_n.html',''); initResiza
  • NeuralNetwork() : machine_learning::neural_network::NeuralNetwork
  • new_val() : statistics::stats_computer1< T >, statistics::stats_computer2< T >
  • newKid() : range_queries::perSegTree
    • -
  • Node() : data_structures::Node, data_structures::tree_234::Node
    • +
  • Node() : data_structures::Node, data_structures::tree_234::Node, operations_on_datastructures::reverse_binary_tree::Node
  • num_digits() : large_number
  • number_of_vertices() : graph::Graph< T >
  • numberOfChildren() : operations_on_datastructures::trie_operations::Tnode
    • diff --git a/functions_func_p.html b/functions_func_p.html index 91147c375..4d3275a8a 100644 --- a/functions_func_p.html +++ b/functions_func_p.html @@ -102,6 +102,7 @@ $(document).ready(function(){initNavTree('functions_func_p.html',''); initResiza
  • predict_words() : data_structures::trie_using_hashmap::Trie
  • preOrderIterative() : others::iterative_tree_traversals::BinaryTree
  • Print() : data_structures::tree_234::Tree234
    • +
  • print() : operations_on_datastructures::reverse_binary_tree::BinaryTree
  • PrintNode() : data_structures::tree_234::Tree234
  • printResult() : FCFS< S, T, E >
  • probability_density() : probability::geometric_dist::geometric_distribution
    • diff --git a/functions_func_r.html b/functions_func_r.html index c9673951c..b75bd14f4 100644 --- a/functions_func_r.html +++ b/functions_func_r.html @@ -103,6 +103,8 @@ $(document).ready(function(){initNavTree('functions_func_r.html',''); initResiza
  • RemoveItemByIndex() : data_structures::tree_234::Node
  • RemovePreMerge() : data_structures::tree_234::Tree234
  • removeWordHelper() : Trie
    • +
  • reverse() : operations_on_datastructures::reverse_binary_tree::BinaryTree
    • +
  • reverseBinaryTree() : operations_on_datastructures::reverse_binary_tree::BinaryTree
  • reverseList() : data_structures::linked_list::list
  • right() : MinHeap
  • RightRotate() : data_structures::tree_234::Tree234
    • diff --git a/functions_g.html b/functions_g.html index 5f31e098a..9216c682b 100644 --- a/functions_g.html +++ b/functions_g.html @@ -108,6 +108,7 @@ $(document).ready(function(){initNavTree('functions_g.html',''); initResizable()
  • get_elements_preorder() : binary_search_tree< T >
  • get_idx_char() : ciphers::HillCipher
  • get_inverse() : ciphers::HillCipher
    • +
  • get_level_order() : operations_on_datastructures::reverse_binary_tree::BinaryTree
  • get_size() : machine_learning::aystar_search::EightPuzzle< N >
  • get_state() : machine_learning::aystar_search::EightPuzzle< N >
  • get_XY_from_csv() : machine_learning::neural_network::NeuralNetwork
    • diff --git a/functions_i.html b/functions_i.html index 7f28ec0c7..7223e2521 100644 --- a/functions_i.html +++ b/functions_i.html @@ -99,8 +99,8 @@ $(document).ready(function(){initNavTree('functions_i.html',''); initResizable()
  • init() : range_queries::heavy_light_decomposition::HLD< X >, range_queries::heavy_light_decomposition::Tree< X >
  • inOrderIterative() : others::iterative_tree_traversals::BinaryTree
  • insert() : binary_search_tree< T >, data_structures::linked_list::list, data_structures::list_array::list
    • -
  • Insert() : data_structures::tree_234::Tree234
    • -
  • insert() : data_structures::trie, data_structures::trie_using_hashmap::Trie
    • +
  • Insert() : data_structures::tree_234::Tree234
    • +
  • insert() : data_structures::trie, data_structures::trie_using_hashmap::Trie, operations_on_datastructures::reverse_binary_tree::BinaryTree
  • Insert() : operations_on_datastructures::trie_operations::Tnode
  • insert() : probability::windowed_median::WindowedMedian, Trie
  • insertElement() : data_structures::SkipList
    • diff --git a/functions_l.html b/functions_l.html index b064daf09..dd42a4b75 100644 --- a/functions_l.html +++ b/functions_l.html @@ -98,7 +98,7 @@ $(document).ready(function(){initNavTree('functions_l.html',''); initResizable()
  • last : data_structures::linked_list::list
  • lazy() : range_queries::perSegTree
  • lca() : range_queries::heavy_light_decomposition::Tree< X >
    • -
  • left : binary_search_tree< T >::bst_node, MinHeap, operations_on_datastructures::inorder_traversal_of_bst::Node, others::iterative_tree_traversals::Node
    • +
  • left : binary_search_tree< T >::bst_node, MinHeap, operations_on_datastructures::inorder_traversal_of_bst::Node, operations_on_datastructures::reverse_binary_tree::Node, others::iterative_tree_traversals::Node
  • LeftRotate() : data_structures::tree_234::Tree234
  • level : data_structures::SkipList, graph::RootedTree
  • lift() : range_queries::heavy_light_decomposition::Tree< X >
    • diff --git a/functions_n.html b/functions_n.html index ade98c8ba..f51584578 100644 --- a/functions_n.html +++ b/functions_n.html @@ -101,7 +101,7 @@ $(document).ready(function(){initNavTree('functions_n.html',''); initResizable()
  • new_val() : statistics::stats_computer1< T >, statistics::stats_computer2< T >
  • newKid() : range_queries::perSegTree
  • next : data_structures::linked_list::Node, hash_chain, list, node< Kind >, search::sublist_search::Node
    • -
  • Node() : data_structures::Node, data_structures::tree_234::Node, hash_chain
    • +
  • Node() : data_structures::Node, data_structures::tree_234::Node, hash_chain, operations_on_datastructures::reverse_binary_tree::Node
  • NUM_CHARS : data_structures::trie
  • num_digits() : large_number
  • number_of_vertices() : graph::Graph< T >
    • diff --git a/functions_p.html b/functions_p.html index e8ba7d8f0..5d2ea4d3b 100644 --- a/functions_p.html +++ b/functions_p.html @@ -109,6 +109,7 @@ $(document).ready(function(){initNavTree('functions_p.html',''); initResizable()
  • predict_words() : data_structures::trie_using_hashmap::Trie
  • preOrderIterative() : others::iterative_tree_traversals::BinaryTree
  • Print() : data_structures::tree_234::Tree234
    • +
  • print() : operations_on_datastructures::reverse_binary_tree::BinaryTree
  • PrintNode() : data_structures::tree_234::Tree234
  • printResult() : FCFS< S, T, E >
  • probability_density() : probability::geometric_dist::geometric_distribution
    • diff --git a/functions_r.html b/functions_r.html index e2e07ddcb..b8bc1ef58 100644 --- a/functions_r.html +++ b/functions_r.html @@ -104,10 +104,12 @@ $(document).ready(function(){initNavTree('functions_r.html',''); initResizable()
  • RemoveItemByIndex() : data_structures::tree_234::Node
  • RemovePreMerge() : data_structures::tree_234::Tree234
  • removeWordHelper() : Trie
    • +
  • reverse() : operations_on_datastructures::reverse_binary_tree::BinaryTree
    • +
  • reverseBinaryTree() : operations_on_datastructures::reverse_binary_tree::BinaryTree
  • reverseList() : data_structures::linked_list::list
    • -
  • right : binary_search_tree< T >::bst_node, MinHeap, operations_on_datastructures::inorder_traversal_of_bst::Node, others::iterative_tree_traversals::Node, range_queries::perSegTree::Node
    • +
  • right : binary_search_tree< T >::bst_node, MinHeap, operations_on_datastructures::inorder_traversal_of_bst::Node, operations_on_datastructures::reverse_binary_tree::Node, others::iterative_tree_traversals::Node, range_queries::perSegTree::Node
  • RightRotate() : data_structures::tree_234::Tree234
    • -
  • root : graph::RootedTree
    • +
  • root : graph::RootedTree, operations_on_datastructures::reverse_binary_tree::BinaryTree
  • root_ : binary_search_tree< T >, data_structures::tree_234::Tree234
  • root_node : data_structures::trie_using_hashmap::Trie
  • RootedTree() : graph::RootedTree
    • diff --git a/functions_vars.html b/functions_vars.html index 56e4f30f1..5764af2ae 100644 --- a/functions_vars.html +++ b/functions_vars.html @@ -122,7 +122,7 @@ $(document).ready(function(){initNavTree('functions_vars.html',''); initResizabl

    - d -