gitextract_r3ies5y1/

├── .gitignore
├── BST/
│   ├── BinarySearchTree.java
│   ├── Delete.c
│   ├── Height.c
│   ├── Insert & Search.cpp
│   ├── MinMax_8.c
│   ├── checkbst
│   ├── createBST.cpp
│   ├── lca.cpp
│   └── spiraltransversal.c
├── Backtrack/
│   ├── NQueen.cpp
│   ├── Rat_Maze_Recurssion_Backtracking.c
│   ├── nqueen_allsol.py
│   └── permutations_of_string.cpp
├── CONTRIBUTING.md
├── Competitive Programming Challenges/
│   └── C:C++/
│       ├── HackerEarth:CodeForces/
│       │   ├── buy_max_with_given_money.cpp
│       │   ├── median searching efficientalgo.cpp
│       │   ├── ques/
│       │   │   └── volcano.cpp
│       │   ├── ques-beat_the_clock/
│       │   │   └── spiral_matrix.cpp
│       │   ├── ques-l1/
│       │   │   ├── codeforces_426_2.cpp
│       │   │   ├── positions.cpp
│       │   │   └── snake/
│       │   │       ├── snake.cpp
│       │   │       └── wrong_snake.cpp
│       │   └── searchmat.cpp
│       └── Patterns/
│           ├── pattern1.cpp
│           ├── pattern2.cpp
│           ├── pattern3.cpp
│           ├── pattern4.cpp
│           ├── pattern6.cpp
│           └── pattern7.cpp
├── Conversions/
│   └── C:C++/
│       └── binary2octal.c
├── Data Structures/
│   ├── C:C++/
│   │   ├── Applications/
│   │   │   ├── Evaluating Postfix Expression.c
│   │   │   ├── Infix to Postfix.c
│   │   │   ├── balance parenthesis.cpp
│   │   │   └── stack_and_its_implementation.c
│   │   ├── Graph/
│   │   │   ├── FloydWarshall.cpp
│   │   │   ├── adjacency_list.hpp
│   │   │   ├── adjacency_matrix.hpp
│   │   │   ├── bfs_dfs/
│   │   │   │   ├── bfs/
│   │   │   │   │   ├── BFS.java
│   │   │   │   │   └── bfs.Py
│   │   │   │   └── ques/
│   │   │   │       ├── graph_connected_components.cpp
│   │   │   │       └── tbbfs.cpp
│   │   │   ├── dijakstra/
│   │   │   │   ├── Dijkstra.java
│   │   │   │   ├── dist_from_source.cpp
│   │   │   │   ├── dist_from_source_oops.cpp
│   │   │   │   └── ques/
│   │   │   │       ├── min_path.cpp
│   │   │   │       └── qgrid_11.cpp
│   │   │   ├── shortest_paths.hpp
│   │   │   ├── topological_sort.hpp
│   │   │   └── tree/
│   │   │       └── binarySearchTree/
│   │   │           └── bsTree.cpp
│   │   ├── Linked List/
│   │   │   ├── Circular_LL.c
│   │   │   ├── Circular_ll.cpp
│   │   │   ├── Doubly LL.c
│   │   │   ├── Insertion_Deletion_SinglyLL.c
│   │   │   ├── Queue using LinkedList.cpp
│   │   │   ├── Queue_using_linkedlist.c
│   │   │   ├── Reverse_SinglyLL.c
│   │   │   ├── all_operations_of_Doubly_ll.cpp
│   │   │   ├── concatinate.c
│   │   │   ├── doubly circular.c
│   │   │   ├── doubly linked list.c
│   │   │   ├── linked_list.c
│   │   │   ├── ordered_linked.c
│   │   │   ├── reverse.cpp
│   │   │   ├── stackLinkedList.cpp
│   │   │   └── stack_Linked_List.c
│   │   ├── Stack/
│   │   │   ├── Balanced_Brackets.cpp
│   │   │   ├── Reverse_Queue.cpp
│   │   │   ├── Stack_as_linked_list.cpp
│   │   │   ├── largestRectangleHistogram.cpp
│   │   │   ├── nextgreaterelement
│   │   │   └── stack.hpp
│   │   ├── Trees/
│   │   │   ├── segment_tree/
│   │   │   │   ├── segment_tree.cpp
│   │   │   │   └── segment_trees_lazy.cpp.cpp
│   │   │   └── tree/
│   │   │       ├── Fenwick_tree.cpp
│   │   │       ├── bst.hpp
│   │   │       ├── segment_tree.hpp
│   │   │       ├── tree.hpp
│   │   │       └── trie.cpp
│   │   └── queue/
│   │       └── queue.hpp
│   ├── Java/
│   │   └── Stack/
│   │       └── Stack.java
│   └── Python/
│       ├── Graphs/
│       │   ├── Graph.py
│       │   └── dfs.py
│       ├── Linked List/
│       │   └── singly_linked_list.py
│       ├── Queue/
│       │   └── Queue.py
│       ├── Stack/
│       │   └── stack.py
│       └── Trees/
│           └── m-coloring-problem.py
├── Dynamic Programing/
│   ├── Dynamic_fibonacci.py
│   ├── Edit Distance.Py
│   ├── Knapsack.py
│   ├── Memoized Cut Rod.Py
│   ├── Word_Wrap.Py
│   └── longest_increasing_subsequence.cpp
├── Mathematical Challenges/
│   ├── C:C++/
│   │   ├── Fibonacci/
│   │   │   └── Fibonacci Test.cpp
│   │   ├── Square Root Decomposition/
│   │   │   └── MO's Algorithm/
│   │   │       └── MOAlgo.cpp
│   │   ├── armstrong_number/
│   │   │   ├── C/
│   │   │   │   └── armstrong.c
│   │   │   └── README.md
│   │   ├── convexHull/
│   │   │   └── ConvexHullScan.cpp
│   │   ├── factorial/
│   │   │   └── factorial.c
│   │   ├── fibbinacci/
│   │   │   └── fibbinacci.c
│   │   ├── gcd/
│   │   │   ├── extended_gcd.cpp
│   │   │   ├── gcd.cpp
│   │   │   └── mod_inverse.cpp
│   │   ├── largestoutof3/
│   │   │   └── largestoutof3.c
│   │   ├── mathpuzzle.c/
│   │   │   └── matchstick game
│   │   ├── multiplication/
│   │   │   └── multiply 2 numbers greater than 10^6.cpp
│   │   ├── power/
│   │   │   ├── modular_exponention.cpp
│   │   │   ├── ques/
│   │   │   │   └── summation.cpp
│   │   │   └── two_pow.cpp
│   │   ├── powerset/
│   │   │   └── PowerSet.java
│   │   ├── prime/
│   │   │   ├── PrimeCheck.py
│   │   │   ├── PrimeToNumber.py
│   │   │   ├── prime.c
│   │   │   └── sieveOferatosthenes.cpp
│   │   ├── prime number tricks/
│   │   │   └── List all primes.cpp
│   │   └── ques/
│   │       └── cpcrc1c.cpp
│   └── python/
│       ├── pernicious_prime/
│       │   └── pernicious.py
│       └── sieve_of_eratoshthenes.py
├── Patterns/
│   ├── pattern10.cpp
│   ├── pattern11.cpp
│   ├── pattern12.cpp
│   ├── pattern13.cpp
│   ├── pattern14.cpp
│   ├── pattern15.cpp
│   ├── pattern16.cpp
│   ├── pattern8.cpp
│   └── pattern9.cpp
├── README.md
├── STL C++/
│   ├── STACK_with_Application/
│   │   ├── Evaluating Postfix Expression.c
│   │   ├── Infix to Postfix.c
│   │   ├── balance parenthesis.cpp
│   │   └── stack_and_its_implementation.c
│   ├── sorting_a_vector.cpp
│   ├── stack/
│   │   ├── Stack.java
│   │   ├── largestRectangleHistogram.cpp
│   │   └── stack.hpp
│   ├── using_map.cpp
│   └── using_set.cpp
├── STRUCTURE.md
├── Searching Algorithms/
│   ├── Bogo_sort.cpp
│   ├── C:C++/
│   │   ├── Binary_Search.cpp
│   │   ├── Binary_search.cpp
│   │   ├── Interpolation Search
│   │   ├── Interpolation_search.cpp
│   │   ├── Jump_Search.cpp
│   │   ├── Liear_search.cpp
│   │   ├── MEDIAN_SEARCH.cpp
│   │   ├── Selection_sort.cpp
│   │   ├── Ternary_search.cpp
│   │   ├── b_search.cpp
│   │   ├── fibonacci_search.cpp
│   │   ├── seaching algorithms [rename]/
│   │   │   ├── binary_search.cpp
│   │   │   ├── binary_search_extras/
│   │   │   │   ├── position_in_sorted_array/
│   │   │   │   │   ├── eq_less_than.cpp
│   │   │   │   │   ├── first_occurance.cpp
│   │   │   │   │   ├── just_less_than_num.cpp
│   │   │   │   │   └── position_in_sorted_array.cpp
│   │   │   │   └── ques/
│   │   │   │       └── aggrcow.cpp
│   │   │   ├── jump_search.cpp
│   │   │   └── linear.cpp
│   │   ├── ternarySearch.cpp
│   │   └── ternary_search.c
│   ├── Java/
│   │   ├── TODO
│   │   ├── algos/
│   │   │   ├── BinarySearch.java
│   │   │   └── LinearSearch.java
│   │   └── driving.java
│   └── Python/
│       ├── binarysearch.py
│       └── bst.py
├── Segment Trees/
│   ├── ADA/
│   │   ├── README.md
│   │   └── segmentree.adb
│   ├── C++/
│   │   ├── RangeMinimumQuery.cpp
│   │   └── SumInGivenRange.cpp
│   └── Java/
│       ├── SegementTree.java
│       └── SegementTreeLazyPropagation.java
├── Sorting Algorithms/
│   ├── C:C++/
│   │   ├── Counting_Sort.cpp
│   │   ├── Insertion_sort.cpp
│   │   ├── Merge_sort.cpp
│   │   ├── QuickSort.c
│   │   ├── Quick_sort.cpp
│   │   ├── Radix_sort.cpp
│   │   ├── bubblesort.c
│   │   ├── bubblesort.cpp
│   │   ├── bucketsort.c
│   │   ├── heapSort.c
│   │   ├── insertion.hpp
│   │   ├── merge.hpp
│   │   ├── quick.hpp
│   │   ├── quick_sort.c
│   │   ├── radix.hpp
│   │   ├── selectionsort.c
│   │   ├── shell_sort.h
│   │   ├── slow.cpp
│   │   └── sorting_a_vector.cpp
│   ├── Java/
│   │   ├── Countsort.java
│   │   ├── HeapSort.java
│   │   └── MergeSort.java
│   ├── Javascript/
│   │   └── bubblesort.js
│   ├── Python/
│   │   ├── QuickSort.py
│   │   ├── bogosort.py
│   │   ├── bubblesort.py
│   │   ├── cocktailsort.py
│   │   ├── insertionsort.py
│   │   ├── mergesort.py
│   │   ├── quicksort.py
│   │   └── topological_sort.py
│   └── sleep sort.c
├── String Manipulation/
│   ├── C:C++/
│   │   ├── String_algo/
│   │   │   ├── KMP.cpp
│   │   │   ├── SUFFIX-ARRAY.cpp
│   │   │   └── z_algorithm.cpp
│   │   └── tokens/
│   │       ├── token_break.cpp
│   │       └── word_break.cpp
│   └── Python/
│       └── LCS.py
├── backtrack/
│   └── sudoku/
│       ├── code2.cpp
│       └── sudoku.cpp
├── binary_tree/
│   └── binarytree.java
├── btree.cpp
├── cryptography/
│   ├── Python/
│   │   └── porta.py
│   └── des/
│       └── java/
│           ├── Converter.java
│           ├── DES.java
│           ├── IO.java
│           └── Main.java
├── dfs.cpp
├── disjoint_set/
│   └── disjoint_set.hpp
├── divide_and_conquer/
│   ├── maximum_sub_array.cpp
│   └── strassen.cpp
├── dp/
│   ├── 0-1knapsack.cpp
│   ├── Digit_dp.cpp
│   ├── coinchange.cpp
│   ├── editDistance.cpp
│   ├── eggdropping.cpp
│   ├── kadane.cpp
│   ├── lcs.cpp
│   ├── lis.cpp
│   └── mcm.cpp
├── euler_totent_function
├── genome_sort.py
├── graph/
│   ├── Kosaraju_algorithm
│   └── bfs_dfs/
│       ├── bfs/
│       │   ├── BFS.cpp
│       │   ├── BFS.py
│       │   └── bfs.cpp
│       └── dfs/
│           ├── DFS.cpp
│           └── DFS.java
├── heap/
│   ├── heap.hpp
│   └── min_heap.cpp
├── os/
│   └── scheduling/
│       ├── fcfs.cpp
│       ├── os_priority.cpp
│       ├── os_roundrobin.cpp
│       ├── os_sjf.cpp
│       ├── os_srtf.cpp
│       └── readme.txt
├── shellsort.c
├── sieve_of_eratoshthenes.cpp
├── square_root_decomposition
└── travelling_salesman_problem