SYMBOL INDEX (1293 symbols across 261 files)

FILE: algorithms/EuclideanAlgorithm/c/euclid.c
  function gcd (line 3) | int gcd(int x, int y){
  function main (line 9) | void main(){

FILE: algorithms/EuclideanAlgorithm/python/euclideanAlgorithm.py
  function euclidean (line 1) | def euclidean(a,b):#for natural numbers a,b

FILE: algorithms/Graph/connected_components_in_undirected_graph/python/ConnectedComponents.py
  function countComponents (line 9) | def countComponents( n, edges):

FILE: algorithms/a_search/cpp/a_star.cpp
  type cell (line 15) | struct cell
  function isValid (line 26) | bool isValid(int row, int col)
  function isUnBlocked (line 36) | bool isUnBlocked(int grid[][COL], int row, int col)
  function isDestination (line 47) | bool isDestination(int row, int col, Pair dest)
  function calculateHValue (line 56) | double calculateHValue(int row, int col, Pair dest)
  function tracePath (line 65) | void tracePath(cell cellDetails[][COL], Pair dest)
  function aStarSearch (line 97) | void aStarSearch(int grid[][COL], Pair src, Pair dest)
  function main (line 636) | int main()

FILE: algorithms/backtracking/c/n_queens_problem.c
  function printSolution (line 7) | void printSolution(int board[N][N])
  function isSafe (line 23) | bool isSafe(int board[N][N], int row, int col)
  function solveNQUtil (line 47) | bool solveNQUtil(int board[N][N], int col)
  function solveNQ (line 89) | bool solveNQ()
  function main (line 108) | int main()

FILE: algorithms/backtracking/c/rat_in_a_maze_problem.c
  function printSolution (line 11) | void printSolution(int sol[N][N])
  function isSafe (line 22) | bool isSafe(int maze[N][N], int x, int y)
  function solveMaze (line 36) | bool solveMaze(int maze[N][N])
  function solveMazeUtil (line 55) | bool solveMazeUtil(int maze[N][N], int x, int y, int sol[N][N])
  function main (line 89) | int main()

FILE: algorithms/backtracking/c/sudoku_problem.c
  function SolveSudoku (line 19) | bool SolveSudoku(int grid[N][N])
  function FindUnassignedLocation (line 51) | bool FindUnassignedLocation(int grid[N][N], int &row, int &col)
  function UsedInRow (line 62) | bool UsedInRow(int grid[N][N], int row, int num)
  function UsedInCol (line 72) | bool UsedInCol(int grid[N][N], int col, int num)
  function UsedInBox (line 82) | bool UsedInBox(int grid[N][N], int boxStartRow, int boxStartCol, int num)
  function isSafe (line 93) | bool isSafe(int grid[N][N], int row, int col, int num)
  function printGrid (line 103) | void printGrid(int grid[N][N])
  function main (line 114) | int main()

FILE: algorithms/backtracking/c/the_knight_tour_problem.c
  function isSafe (line 10) | bool isSafe(int x, int y, int sol[N][N])
  function printSolution (line 17) | void printSolution(int sol[N][N])
  function solveKT (line 34) | bool solveKT()
  function solveKTUtil (line 67) | int solveKTUtil(int x, int y, int movei, int sol[N][N],
  function main (line 94) | int main()

FILE: algorithms/bellman_ford/cpp/bellman_ford.cpp
  function main (line 13) | int main()

FILE: algorithms/bellman_ford/java/BellmanFord.java
  class Graph (line 3) | class Graph
    class Edge (line 5) | private class Edge {
      method Edge (line 7) | private Edge(int src, int dest, int weight) {
    method Graph (line 16) | public Graph(int v)
    method bellmanFord (line 22) | public void bellmanFord(int src) {
    method printArr (line 61) | private void printArr(int dist[], int V)
    method addEdge (line 68) | public boolean addEdge(int src, int dest, int weight) {
    method main (line 78) | public static void main(String[] args)

FILE: algorithms/bfs/cpp/bfs.cpp
  class Vertex (line 6) | class Vertex {
  class Queue (line 24) | class Queue{
    method Queue (line 26) | Queue(Vertex *first){
    method Enqueue (line 31) | void Enqueue(Vertex *pred_, Vertex * cur) {
    method Vertex (line 41) | Vertex * Dequeue(){
    method isEmpty (line 47) | bool isEmpty(){
    method isInQueue (line 51) | bool isInQueue(Vertex v){
  function BFS (line 66) | void BFS(Vertex *root) {
  function main (line 85) | int main() {

FILE: algorithms/bfs/java/Graph.java
  class Graph (line 6) | public class Graph {
    method Graph (line 14) | public Graph(int v) {
    method addEdge (line 26) | public void addEdge(int v, int w)  {
    method BFS (line 34) | public void BFS(int source) {
    method main (line 59) | public static void main(String args[]) {

FILE: algorithms/binary_search/PHP/binarysearch.php
  function binary_search (line 7) | function binary_search( $sourceArr, $keyword )

FILE: algorithms/binary_search/c/binary_search.c
  function binarySearch (line 3) | int binarySearch(int arr[], int l, int r, int key) {
  function main (line 20) | int main(void) {

FILE: algorithms/binary_search/cpp/binary_search.cpp
  function binarySearchIterative (line 5) | bool binarySearchIterative(int list[], int first, int end, int item){
  function binarySearchRecursive (line 23) | bool binarySearchRecursive(int list[], int first, int end, int item){
  function main (line 41) | int main(int argc, char const *argv[]){

FILE: algorithms/binary_search/java/binarysearch.java
  class BinarySearch (line 2) | class BinarySearch
    method binarySearch (line 5) | int binarySearch(int ar[], int l, int r, int x){
    method main (line 27) | public static void main(String args[])

FILE: algorithms/binary_search/javascript/binary_search.js
  function binarySearch (line 1) | function binarySearch(ar, el, compare_fn) {

FILE: algorithms/binary_search/python/binary_search.py
  function b_search (line 3) | def b_search(a,s,start,end):

FILE: algorithms/binary_search/ruby/binary_search.rb
  function binary_search (line 1) | def binary_search(an_array, item)

FILE: algorithms/bipartite_check/cpp/bipartite.cpp
  function bipartite (line 6) | bool bipartite(int src)
  function main (line 30) | int main()

FILE: algorithms/bitwise/cpp/generating_subsets.cpp
  function main (line 8) | int main(void)

FILE: algorithms/bitwise/java/AddTwoNumbersWithoutPlusOperator.java
  class AddTwoNumbersWithoutPlusOperator (line 2) | public class AddTwoNumbersWithoutPlusOperator {
    method main (line 3) | public static void main(String[] args) {
    method add (line 9) | private static void add(int a, int b) {

FILE: algorithms/bitwise/java/BinaryPalidrome.java
  class BinaryPalidrome (line 1) | public class BinaryPalidrome {
    method main (line 3) | public static void main(String[] args) {
    method isPalidrome (line 12) | private boolean isPalidrome(int n) {
    method kthBit (line 25) | private int kthBit(int n, int kthBit) {
    method getTotalBits (line 29) | private int getTotalBits(int n) {

FILE: algorithms/bitwise/java/NegateANumberWithoutPlusOperator.java
  class NegateANumberWithoutPlusOperator (line 1) | public class NegateANumberWithoutPlusOperator {
    method main (line 2) | public static void main(String[] args) {
    method negate (line 8) | private int negate(int n) {
    method add (line 12) | private int add(int a, int b) {

FILE: algorithms/bitwise/java/Subsets.java
  class Subsets (line 7) | public class Subsets {
    method main (line 8) | public static void main(String[] args) {
    method printSubsets (line 14) | private void printSubsets(char[] set) {

FILE: algorithms/bogo_sort/java/BogoSort.java
  class BogoSort (line 5) | public class BogoSort {
    method bogoSort (line 7) | public static List<Integer> bogoSort(List<Integer> nums) {
    method isSorted (line 23) | public static boolean isSorted(List<Integer> x) {

FILE: algorithms/bogo_sort/python/bogo.py
  function inorder (line 8) | def inorder(x):
  function bogo (line 17) | def bogo(x):

FILE: algorithms/bogo_sort/ruby/bogo_sort.rb
  function bogosort (line 1) | def bogosort(arr)

FILE: algorithms/breadth_first_search/cpp/bfs.cpp
  class Graph (line 7) | class Graph
  function main (line 65) | int main()

FILE: algorithms/bubble_sort/c/bubble_sort.c
  function bubbleSort (line 11) | void bubbleSort(int arr[], int n)
  function main (line 22) | int main()

FILE: algorithms/bubble_sort/cpp/bubble_sort_1.cpp
  function bubble_sort (line 8) | void bubble_sort()
  function main (line 24) | int main()

FILE: algorithms/bubble_sort/cpp/bubblesort.cpp
  function main (line 5) | void main()

FILE: algorithms/bubble_sort/csharp/BubbleSort.cs
  class BubbleSort (line 5) | public class BubbleSort {
    method Main (line 6) | private static void Main(string[] args) {
    method BubbleSort (line 32) | private static void BubbleSort(IList<int> list) {

FILE: algorithms/bubble_sort/elixir/bubblesort.ex
  class BubbleSort (line 1) | defmodule BubbleSort
    method sort (line 2) | def sort([]),  do: []
    method sort (line 3) | def sort(list) do
    method swap (line 11) | defp swap([head | []]), do: [head]
    method swap (line 12) | defp swap([head | [second | tail]]) do

FILE: algorithms/bubble_sort/go/bubble-sort-algorithm.go
  function main (line 5) | func main() {
  function bubbleSort (line 13) | func bubbleSort(numbers []int) {
  function sweep (line 21) | func sweep(numbers []int) {

FILE: algorithms/bubble_sort/java/BubbleSortExample.java
  class BubbleSortExample (line 3) | public class BubbleSortExample {
    method bubbleSort (line 5) | private static void bubbleSort(int[] arr) {
    method main (line 21) | public static void main(String[] args) {

FILE: algorithms/bubble_sort/java/GenericBubbleSort.java
  class GenericBubbleSort (line 2) | class GenericBubbleSort {
    method bubble_sort (line 4) | public static <T extends Comparable<T>> void bubble_sort(T array[]){
    method swap (line 20) | private static <T> void swap(int index, T[] array){
    method printArray (line 26) | private static <T> void printArray(T[] input){
    method main (line 33) | public static void main(String[] args){

FILE: algorithms/bubble_sort/javascript/bubble-sort.js
  function bubbleSort (line 1) | function bubbleSort(a)

FILE: algorithms/bubble_sort/javascript/bubbleSort.js
  function bubbleSort (line 1) | function bubbleSort(array) {

FILE: algorithms/bubble_sort/javascript/main_bs.js
  function readInput (line 13) | function readInput() {

FILE: algorithms/bubble_sort/python/bubble_sort.py
  function bubbleSort (line 1) | def bubbleSort(a):

FILE: algorithms/bubble_sort/ruby/bubble_sort.rb
  function bubble_sort (line 1) | def bubble_sort(array)

FILE: algorithms/bucket_sort/bucket_sort.cpp
  function bucketSort (line 8) | void bucketSort(float arr[], int n)
  function main (line 32) | int main()

FILE: algorithms/bucket_sort/bucket_sort.java
  class Bucket_Sort (line 4) | public class Bucket_Sort
    method sort (line 6) | static int[] sort(int[] sequence, int maxValue)
    method printSequence (line 23) | static void printSequence(int[] sorted_sequence)
    method maxValue (line 29) | static int maxValue(int[] sequence)
    method main (line 38) | public static void main(String args[])

FILE: algorithms/bucket_sort/bucket_sort.py
  function bucketsort (line 1) | def bucketsort( A ):
  function hashing (line 31) | def hashing( A ):
  function re_hashing (line 40) | def re_hashing( i, code ):

FILE: algorithms/bucket_sort/c/bucket_sort.c
  function Bucket_Sort (line 13) | void Bucket_Sort(int array[], int n)
  function main (line 47) | int main()

FILE: algorithms/caesar_cipher/java/caesar.java
  class Caesar (line 7) | public class Caesar {
    method encode (line 8) | public static String encode (String message,int shift)
    method decode (line 54) | public static String decode (String message,int shift)
    method main (line 100) | public static void main(String[] args)

FILE: algorithms/caesar_cipher/javascript/caesarCipher.js
  constant LEGAL_VALUES (line 1) | const LEGAL_VALUES = 'abcdefghijklmnopqrstuvwxyz';
  constant START_CODE (line 2) | const START_CODE = 'a'.charCodeAt(0);
  constant END_CODE (line 3) | const END_CODE = 'z'.charCodeAt(0);
  class CaesarCipher (line 5) | class CaesarCipher {
    method constructor (line 6) | constructor(key) {
    method generateKey (line 16) | generateKey() {
    method validateKey (line 25) | validateKey() {
    method encode (line 36) | encode(decodedMessage) {
    method decode (line 59) | decode(encodedMessage) {

FILE: algorithms/check_pallindrome_number/c/checkPalindrome.c
  function checkPall (line 4) | int checkPall(char str[])
  function main (line 15) | int main()

FILE: algorithms/check_pallindrome_number/cpp/checkPall.cpp
  function checkPall (line 5) | int checkPall(char str[])
  function main (line 16) | int main()

FILE: algorithms/closest/java/Closest.java
  class Closest (line 11) | public class Closest {
    method main (line 12) | public static void main(String[] args) {

FILE: algorithms/cycle_sort/java/cycleSort.java
  class GFG (line 6) | class GFG
    method cycleSort (line 9) | public static void cycleSort (int arr[], int n)
    method main (line 72) | public static void main(String[] args)

FILE: algorithms/decoding/c/base64_decoder.c
  function val (line 18) | int val(char x){
  function main (line 25) | int main() {

FILE: algorithms/dfs/cpp/dfs.cpp
  class Vertex (line 8) | class Vertex {
  function VisitVertex (line 25) | void VisitVertex(Vertex *v, Vertex * predecessor){
  function DFS (line 34) | void DFS(std::vector <Vertex *> graph){
  function main (line 47) | int main() {

FILE: algorithms/dfs/java/Graph.java
  class Graph (line 6) | class Graph {
    method Graph (line 14) | Graph(int v) {
    method addEdge (line 26) | public void addEdge(int v, int w)  {
    method DFSUtil (line 35) | private void DFSUtil(int v, boolean visited[])  {
    method DFS (line 49) | void DFS(int source) {
    method main (line 59) | public static void main(String args[]) {

FILE: algorithms/dfs/python/Dfs.py
  class Graph (line 8) | class Graph:
    method __init__ (line 11) | def __init__(self):
    method addEdge (line 17) | def addEdge(self,u,v):
    method DFSUtil (line 21) | def DFSUtil(self,v,visited):
    method DFS (line 35) | def DFS(self,v):

FILE: algorithms/dijkstra/cpp/Dijkstras.cpp
  function minDistance (line 12) | int minDistance(int dist[], bool sptSet[])
  function printSolution (line 25) | int printSolution(int dist[], int n)
  function dijkstra (line 34) | void dijkstra(int graph[V][V], int src)
  function main (line 75) | int main()

FILE: algorithms/dijkstra/java/ShortestPath.java
  class ShortestPath (line 5) | public class ShortestPath {
    method minDistance (line 8) | private int minDistance(int dist[], Boolean sptSet[]) {
    method printSolution (line 22) | private void printSolution(int dist[]) {
    method dijkstra (line 34) | public void dijkstra(int graph[][], int source) {
    method main (line 67) | public static void main (String[] args) {

FILE: algorithms/dijkstra/python/djikstra.py
  class Graph (line 1) | class Graph:
    method __init__ (line 2) | def __init__(self):
    method add_node (line 7) | def add_node(self, value):
    method add_edge (line 10) | def add_edge(self, from_node, to_node, distance):
  function dijsktra (line 16) | def dijsktra(graph, initial):

FILE: algorithms/doomsday/java/doomsday.java
  class Doomsday (line 7) | public class Doomsday {
    method dow (line 18) | public static int dow(int y, int m, int d) {
    method dowS (line 33) | public static String dowS(int y, int m, int d) {
    method main (line 48) | public static void main(String[] args) {

FILE: algorithms/doomsday/javascript/doomsday.js
  function dayOfTheWeek (line 1) | function dayOfTheWeek(y, m, d) {

FILE: algorithms/dynamic_programming/c/0_1_knapsack_problem.c
  function max (line 5) | int max(int a, int b) { return (a > b)? a : b; }
  function knapSack (line 8) | int knapSack(int W, int wt[], int val[], int n)
  function main (line 30) | int main()

FILE: algorithms/dynamic_programming/c/Coin_change_DP.c
  function count (line 17) | int count( int S[], int m, int n )
  function main (line 48) | int main()

FILE: algorithms/dynamic_programming/c/coinChange.c
  function count (line 2) | int count( int S[], int m, int n )
  function main (line 24) | int main()

FILE: algorithms/dynamic_programming/c/count_no_of_ways_to_reach_nth_stair.c
  function countWaysUtil (line 6) | int countWaysUtil(int n, int m)
  function countWays (line 20) | int countWays(int s, int m)
  function main (line 26) | int main ()

FILE: algorithms/dynamic_programming/c/longestIncreasingSubsequence.c
  function lis (line 7) | int lis( int arr[], int n )
  function main (line 34) | int main()

FILE: algorithms/dynamic_programming/c/longestRepeatedSequence.c
  function string (line 9) | string longestRepeatedSubSeq(string str)
  function main (line 64) | int main()

FILE: algorithms/dynamic_programming/c/longest_pallindrome_sequence.c
  function max (line 7) | int max (int x, int y) { return (x > y)? x : y; }
  function lps (line 10) | int lps(char *str)
  function main (line 44) | int main()

FILE: algorithms/dynamic_programming/c/maxSumIncSequence.c
  function maxSumIS (line 7) | int maxSumIS( int arr[], int n )
  function main (line 31) | int main()

FILE: algorithms/dynamic_programming/c/subsetSum.c
  function isSubsetSum (line 5) | bool isSubsetSum(int set[], int n, int sum)
  function main (line 25) | int main()

FILE: algorithms/dynamic_programming/cpp/kadens.cpp
  function maxSubArraySum (line 6) | int maxSubArraySum(int a[], int size)
  function main (line 23) | int main()

FILE: algorithms/dynamic_programming/cpp/nCr.cpp
  function nCrModp (line 5) | int nCrModp(int n, int r, int p)
  function main (line 30) | int main()

FILE: algorithms/dynamic_programming/cpp/subset_sum.cpp
  function m_diff (line 6) | int m_diff(int idx,int sub_sum)
  function main (line 19) | int main()

FILE: algorithms/dynamic_programming/java/MinCostPath.java
  class MinCostPath (line 3) | public class MinCostPath {
    method minCostPathDP (line 5) | public static int minCostPathDP(int arr[][],int row, int column) {
    method main (line 30) | public static void main(String args[]) {

FILE: algorithms/encoding/base64_encoder.c
  function main (line 18) | int main() {

FILE: algorithms/fibonacci/cpp/constexpr-fibonacci.cpp
  function fibonacci (line 4) | constexpr unsigned int fibonacci(unsigned int index) {

FILE: algorithms/floyd_warshall/java/ShortestPath.java
  class ShortestPath (line 5) | public class ShortestPath {
    method floydWarshall (line 9) | public void floydWarshall(int graph[][]) {
    method printSolution (line 30) | private void printSolution(int dist[][]) {
    method main (line 47) | public static void main (String[] args) {

FILE: algorithms/greedy_search/cpp/prims_algorithm.cpp
  function minkey (line 4) | int minkey(int key[], bool mstset[],int n)
  function main (line 18) | int main()

FILE: algorithms/heap_sort/java/heap_sort.java
  class HeapSort (line 8) | public class HeapSort
    method sort (line 12) | public static void sort(int arr[])
    method heapify (line 23) | public static void heapify(int arr[])
    method maxheap (line 30) | public static void maxheap(int arr[], int i)
    method swap (line 47) | public static void swap(int arr[], int i, int j)
    method main (line 54) | public static void main(String[] args)

FILE: algorithms/heap_sort/java/heapsort.java
  class heapsort (line 3) | class heapsort
    method sort (line 5) | public void sort(int arr[])
    method heapify (line 28) | void heapify(int arr[], int n, int i)
    method printArray (line 55) | static void printArray(int arr[])
    method main (line 64) | public static void main(String args[])

FILE: algorithms/heap_sort/javascript/heap_sort.js
  function heap_root (line 3) | function heap_root(input, i) {
  function swap (line 22) | function swap(input, index_A, index_B) {
  function heapSort (line 29) | function heapSort(input) {

FILE: algorithms/heap_sort/python/heap_sort.py
  function heap_sort (line 3) | def heap_sort(heap_iterable):

FILE: algorithms/histogram_equalization/java/HistogramEqualization.java
  class HistogramEqualization (line 19) | public class HistogramEqualization {
    method main (line 21) | public static void main(String[] args) {
  class ImageMatrix (line 30) | class ImageMatrix {
    method ImageMatrix (line 46) | public ImageMatrix(int[][] arr) {
    method getFrequency (line 51) | public int getFrequency(int key) {
    method getCdf (line 56) | public int getCdf(int key) {
    method frequency (line 61) | public HashMap<Integer, Integer> frequency() {
    method cdf (line 66) | public HashMap<Integer, Integer> cdf() {
    method calculateFrequency (line 74) | private void calculateFrequency() {
    method calculateCdf (line 87) | private void calculateCdf() {
    method equalize (line 105) | public ImageMatrix equalize() {
    method toString (line 116) | @Override

FILE: algorithms/huffmann_algorithm/java/Huffman.java
  class Huffman (line 9) | public class Huffman {
    method Huffman (line 14) | public Huffman(String sourceString){
    method encode (line 63) | public String encode(String str){
    method decode (line 75) | public String decode(String str){
    class Pair (line 91) | private class Pair {
      method Pair (line 95) | Pair(int cost, BinaryTree bt){

FILE: algorithms/insertion_sort/c/InsertionSort.c
  function insertionSort (line 4) | void insertionSort(int ar[], int n)
  function print (line 22) | void print(int ar[], int n)
  function main (line 29) | int main()

FILE: algorithms/insertion_sort/cpp/insertion_sort.cpp
  function insertionSort (line 12) | void insertionSort( int tab[], int arraySize ) {
  function printArray (line 22) | void printArray(int arr[], int arraySize) {
  function main (line 27) | int main() {

FILE: algorithms/insertion_sort/java/InsertionSort.java
  class InsertionSort (line 1) | class InsertionSort {
    method insertionSort (line 7) | public static int[] insertionSort(int[] array) {
    method main (line 24) | public static void main(String[] args) {

FILE: algorithms/insertion_sort/javascript/insertionSort.js
  function insertionSort (line 1) | function insertionSort(array) {

FILE: algorithms/insertion_sort/javascript/insertion_sort.js
  function insertionSort (line 1) | function insertionSort(unsortedList) {

FILE: algorithms/insertion_sort/ruby/insertion_sort.rb
  function insertion_sort (line 1) | def insertion_sort(numbers)

FILE: algorithms/inversion_count/cpp/inversion_count.cpp
  function merge (line 4) | long merge(vector<int> &arr, vector<int> &tmp, int left, int mid, int ri...
  function mergeSort (line 26) | long mergeSort(vector<int> &arr, vector<int> &tmp, int left, int right) {
  function countInversions (line 38) | long countInversions(vector<int> arr) {
  function main (line 43) | int main() {

FILE: algorithms/jarvis/cpp/jarvis.cpp
  type Point (line 5) | struct Point
  function orientation (line 15) | int orientation(Point p, Point q, Point r)
  function convexHull (line 25) | void convexHull(Point points[], int n)

FILE: algorithms/johnson_algorithm/cpp/johnson_algorithm.cpp
  function min (line 17) | int min(int a, int b)
  function main (line 33) | int main(int argc, char **argv)

FILE: algorithms/kmp_search/cpp/KMPSearch.cpp
  function main (line 13) | int main(void)
  function Kmp_Search (line 34) | int Kmp_Search()
  function Compute_Prefix_Array (line 57) | void Compute_Prefix_Array()

FILE: algorithms/kmp_search/java/KMPSearch.java
  class KMPSearch (line 2) | public class KMPSearch {
    method main (line 3) | public static void main(String[] args) {
    method demo (line 7) | private void demo() {
    method calculatePrefixArray (line 34) | private void calculatePrefixArray(String s, int[] prefixArray) {

FILE: algorithms/kmp_search/python/KMPSearch.py
  class KMP (line 1) | class KMP:
    method partial (line 2) | def partial(self, pattern):
    method search (line 13) | def search(self, T, P):

FILE: algorithms/linear_search/c/linearsearch.C
  function linear (line 3) | int linear(int a[], int n, int x){
  function main (line 13) | int main(){

FILE: algorithms/linear_search/cpp/linearSearch.cpp
  function linearSearch (line 4) | int linearSearch(int* arr, int size, int num){
  function main (line 12) | int main(){

FILE: algorithms/linear_search/java/LinearSearch.java
  class LinearSearch (line 3) | public class LinearSearch {
    method main (line 5) | public static void main(String args[])

FILE: algorithms/linear_search/python/linear_search.py
  function linear_search (line 1) | def linear_search(a,target):

FILE: algorithms/longest_common_subsequence/cpp/LongestCommonSubsequence.cpp
  function lcs (line 7) | int lcs( char *X, char *Y, int m, int n )
  function max (line 34) | int max(int a, int b)
  function main (line 40) | int main()

FILE: algorithms/longest_common_subsequence/javaj/LCS.java
  method lcs (line 2) | int lcs( char[] X, char[] Y, int m, int n )
  method max (line 24) | int max(int a, int b)
  method main (line 29) | public static void main(String[] args)

FILE: algorithms/longest_common_subsequence/javascript/longest_common_subsequence.js
  function lcs (line 1) | function lcs(a, b) {

FILE: algorithms/longest_common_subsequence/python/LCS.py
  function lcs (line 3) | def lcs(X , Y):

FILE: algorithms/longest_common_substring/java/LongestCommonSubString.java
  class StringManager (line 3) | class StringManager {
    method findLongestCommonSubString (line 5) | public static String findLongestCommonSubString(String str1, String st...
    method main (line 42) | public static void main(String[] args){

FILE: algorithms/matrix_chain_multiplication/cpp/MCM.cpp
  function MatrixChainOrder (line 6) | int MatrixChainOrder(int p[], int n)
  function main (line 44) | int main()

FILE: algorithms/matrix_chain_multiplication/python/MCM.py
  function matrix_chain_multiplication (line 1) | def matrix_chain_multiplication(dimensions):

FILE: algorithms/merge_sort/c#/MergeSort.cs
  class MergeSort (line 5) | class MergeSort
    method Main (line 7) | static void Main(string[] args)
    method Sort (line 17) | static int[] Sort(int[] w)
    method Merge (line 44) | static int[] Merge(int[] u, int[] v)

FILE: algorithms/merge_sort/cpp/merge_sort.cpp
  function merge_sort (line 4) | void merge_sort(int low,int high)
  function merge (line 15) | void merge(int low,int mid,int high)
  function main (line 54) | void main()

FILE: algorithms/merge_sort/java/merge_sort.java
  class MergeSort (line 2) | class MergeSort
    method merge (line 7) | private static void merge(int arr[], int l, int m, int r)
    method sort (line 65) | private static void sort(int arr[], int l, int r)
    method sort (line 83) | public static boolean sort(int[] arr) {
    method printArray (line 96) | public static void printArray(int arr[])
    method main (line 105) | public static void main(String args[])

FILE: algorithms/merge_sort/javascript/MergeSort.js
  function mergeSort (line 3) | function mergeSort(arr)
  function merge (line 15) | function merge(left, right)

FILE: algorithms/merge_sort/python/merge_sort.py
  function merge_sort (line 1) | def merge_sort(li):
  function merge (line 11) | def merge(left, right):

FILE: algorithms/merge_sort/ruby/merge_sort.rb
  function sort (line 1) | def sort(numbers)
  function merge (line 16) | def merge(left, right)

FILE: algorithms/minimum_spanning_tree/cpp/MST.cpp
  function init (line 8) | void init()
  function root (line 16) | int root(int i)
  function unio (line 25) | void unio(int a,int b)
  function ll (line 38) | ll kruskal(){
  function main (line 58) | int main()

FILE: algorithms/optimal_binary_search_tree/java/OptimalBst.java
  class OptimalBst (line 3) | public class OptimalBst {
    method main (line 9) | public static void main(String[] args) {
    method findMinimum (line 53) | public static int findMinimum(int[][] array , int i , int j){

FILE: algorithms/parse_tree/python/parse_tree.py
  class Stack (line 1) | class Stack:
    method __init__ (line 2) | def __init__(self):
    method isEmpty (line 5) | def isEmpty(self):
    method push (line 8) | def push(self, item):
    method pop (line 11) | def pop(self):
    method peek (line 14) | def peek(self):
    method size (line 17) | def size(self):
  class BinaryTree (line 20) | class BinaryTree:
    method __init__ (line 21) | def __init__(self,rootObj):
    method insertLeft (line 26) | def insertLeft(self,newNode):
    method insertRight (line 34) | def insertRight(self,newNode):
    method getRightChild (line 43) | def getRightChild(self):
    method getLeftChild (line 46) | def getLeftChild(self):
    method setRootVal (line 49) | def setRootVal(self,obj):
    method getRootVal (line 52) | def getRootVal(self):
  function buildParseTree (line 56) | def buildParseTree(fpexp):
  function evaluate (line 82) | def evaluate(parseTree):

FILE: algorithms/permutations/java/Permutation.java
  class Permutation (line 2) | public class Permutation
    method permute (line 4) | public void permute(String str, int l, int r)
    method swap (line 22) | public String swap(String a, int i, int j)
    method main (line 32) | public static void main(String[] args)

FILE: algorithms/quick_sort/c/quick_sort.c
  function quicksort (line 2) | void quicksort(int number[25],int first,int last){
  function main (line 31) | int main(){

FILE: algorithms/quick_sort/cpp/quickSort.cpp
  function main (line 9) | int main()
  function quickSort (line 29) | void quickSort(vector<int>& A, int start,int end)
  function partition (line 41) | int partition(vector<int>& A, int start,int end)

FILE: algorithms/quick_sort/csharp/QuickSort.cs
  class QuickSort (line 5) | class QuickSort
    method Main (line 7) | static void Main(string[] args)
    method Sort (line 20) | void Sort(int[] arr, int low, int high)
    method Partition (line 30) | int Partition(int[] arr, int low, int high)

FILE: algorithms/quick_sort/csharp/quicksort.cs
  class QuickSort (line 7) | public class QuickSort
    method Main (line 13) | private static void Main(string[] args)
    method Qsort (line 43) | private static void Qsort(IList<int> list, int left, int right)
    method Partition (line 55) | private static int Partition(IList<int> list, int left, int right)
    method Swap (line 88) | private static void Swap(IList<int> arr, int i, int j)

FILE: algorithms/quick_sort/java/QuickSort.java
  class QuickSort (line 1) | public class QuickSort{
    method quickSort (line 2) | static void quickSort(int[] arr,int start, int end){
    method partition (line 10) | static int partition(int [] arr, int start, int end){
    method swap (line 28) | static void swap(int[] arr,int i, int j){
    method print (line 34) | static void print(int [] arr){
    method main (line 40) | public static void main(String [] args){

FILE: algorithms/quick_sort/javascript/quick_sort.js
  function quicksort (line 3) | function quicksort(arr, p, r) {
  function partition (line 13) | function partition(arr, p, r) {

FILE: algorithms/quick_sort/python/quicksort.py
  function partition (line 1) | def partition(li, start, end):
  function quicksort (line 20) | def quicksort(li, start=0, end=None):

FILE: algorithms/quick_sort/ruby/quick_sort.rb
  function quicksort (line 1) | def quicksort(array)

FILE: algorithms/rabin_karp/java/RabinKarp.java
  class RabinKarp (line 3) | public class RabinKarp {
    method RabinKarp (line 9) | public RabinKarp(String pat)
    method hash (line 20) | private long hash(String key,int M)
    method search (line 29) | public int search(String txt)
    method longPrimeNumber (line 42) | private static long longPrimeNumber()

FILE: algorithms/radixsort/c++/radixsort.cpp
  function getMax (line 5) | int getMax(int arr[], int n)
  function countSort (line 14) | void countSort(int arr[], int n, int exp)
  function radixsort (line 34) | void radixsort(int arr[], int n)
  function print (line 41) | void print(int arr[], int n)
  function main (line 47) | int main()

FILE: algorithms/radixsort/python/lsd_radixsort.py
  function get_digit (line 4) | def get_digit(number, digit):
  function lsd_radix_sort (line 8) | def lsd_radix_sort(array):

FILE: algorithms/selection_sort/c/SelectionSort.c
  function SelectionSort (line 5) | void SelectionSort(int arr[SIZE]){
  function main (line 23) | void main(){

FILE: algorithms/selection_sort/java/SelectionSort.java
  class SelectionSort (line 2) | class SelectionSort
    method sort (line 5) | void sort(int ar[])
    method printArray (line 21) | void printArray(int arr[])
    method main (line 28) | public static void main(String args[])

FILE: algorithms/selection_sort/python/selection_sort.py
  function selectionsort (line 9) | def selectionsort(a):

FILE: algorithms/selection_sort/ruby/selection_sort.rb
  function selection_sort (line 1) | def selection_sort(input_arr)

FILE: algorithms/shell_sort/C++/ShellSort.cpp
  function shellSort (line 6) | int shellSort(int arr[], int n)
  function printArray (line 34) | void printArray(int arr[], int n)
  function main (line 40) | int main()

FILE: algorithms/shell_sort/C/ShellSort.c
  function shellsort (line 3) | void shellsort(int arr[], int num)
  function main (line 26) | int main()

FILE: algorithms/shell_sort/Java/ShellSort.java
  class ShellSort (line 2) | class ShellSort
    method printArray (line 5) | static void printArray(int arr[])
    method sort (line 14) | int sort(int arr[])
    method main (line 47) | public static void main(String args[])

FILE: algorithms/shell_sort/python/shellsort.py
  function shellSort (line 1) | def shellSort(arr):

FILE: algorithms/sieve_of_eratosthenes/cpp/sieve_of_eratosthenes.cpp
  function SieveOfEratosthenes (line 6) | void SieveOfEratosthenes(int n)
  function main (line 32) | int main()

FILE: algorithms/sieve_of_eratosthenes/java/sieve.java
  class sieve (line 5) | public class sieve
    method sievefunction (line 10) | private void sievefunction(int n, boolean primearr[])
    method print (line 34) | private void print(int n, boolean primearr[])
    method main (line 46) | public static void main(String args[]) throws IOException

FILE: algorithms/sieve_of_eratosthenes/python/sieve.py
  function run_sieve (line 1) | def run_sieve(N, isPrime):
  function print_sieve (line 9) | def print_sieve(N, isPrime):
  function sieve (line 15) | def sieve(N):

FILE: algorithms/sort/heap_sort/java/heap_sort.java
  class HeapSort (line 2) | public class HeapSort
    method sort (line 4) | public void sort(int arr[])
    method heapify (line 27) | void heapify(int arr[], int n, int i)
    method printArray (line 54) | static void printArray(int arr[])
    method main (line 63) | public static void main(String args[])

FILE: algorithms/strings/cpp/anagrams.cpp
  function isAnagram (line 4) | bool isAnagram(string a, string b)
  function findAnagrams (line 13) | vector<int> findAnagrams(string arr[], int n)
  function main (line 33) | int main(int argc, char const *argv[])

FILE: algorithms/tower_of_hanoi/cpp/tower_of_hanoi.cpp
  function main (line 5) | int main(){
  function Hanoi (line 15) | void Hanoi(int m, char a, char b, char c)

FILE: algorithms/tower_of_hanoi/java/towers_of_hanoi.java
  class TowersOfHanoi (line 1) | public class TowersOfHanoi {
    method solve (line 3) | public void solve(int n, String start, String auxiliary, String end) {
    method main (line 13) | public static void main(String[] args) {

FILE: algorithms/tower_of_hanoi/javascript/tower_of_hanoi.js
  function moveDisk (line 3) | function moveDisk(from_pole, to_pole) {
  function towerOfHanoi (line 9) | function towerOfHanoi(height, from_pole=1, to_pole=2, aux=3) {

FILE: algorithms/tower_of_hanoi/php/towers_of_hanoi.php
  function move (line 3) | function move($n, $src, $dest, $temp ){

FILE: algorithms/tower_of_hanoi/python/tower_of_hanoi.py
  function move_disk (line 2) | def move_disk(from_pole, to_pole):
  function tower_of_hanoi (line 8) | def tower_of_hanoi(height, from_pole=1, to_pole=2, aux=3):

FILE: data_structures/arraylist/java/arraylist.java
  class arraylist (line 2) | public class arraylist {
    method main (line 4) | public static void main(String args[]) {

FILE: data_structures/avl_tree/java/AVL.java
  class AVL (line 1) | public class AVL {
    class Node (line 2) | class Node {
      method Node (line 5) | public Node(int data, int height) {
    method getHeight (line 13) | private int getHeight(Node root) {
    method getBalance (line 18) | private int getBalance(Node root) {
    method rightRotate (line 23) | private Node rightRotate(Node root) {
    method leftRotate (line 35) | private Node leftRotate(Node root) {
    method insert (line 47) | public void insert(int data) {
    method insert (line 51) | private Node insert(Node root, int data, int height) {
    method preorder (line 77) | public void preorder() {
    method preorder (line 81) | private void preorder(Node root) {
    method main (line 88) | public static void main(String[] args) {

FILE: data_structures/bag/java/Bag.java
  class Bag (line 11) | public class Bag<Element> implements Iterable<Element> {
    class Node (line 16) | private static class Node<Element> {
    method Bag (line 24) | public Bag() {
    method isEmpty (line 32) | public boolean isEmpty() {
    method size (line 39) | public int size() {
    method add (line 46) | public void add(Element element) {
    method contains (line 60) | public boolean contains(Element element) {
    method iterator (line 73) | public Iterator<Element> iterator() {
    class ListIterator (line 77) | @SuppressWarnings("hiding")
      method ListIterator (line 81) | public ListIterator(Node<Element> firstElement) {
      method hasNext (line 85) | public boolean hasNext() {
      method remove (line 92) | @Override
      method next (line 97) | public Element next() {
    method main (line 109) | public static void main(String[] args) {

FILE: data_structures/binary_search_tree/c/BSTtraversal.c
  type node (line 7) | struct node
  type node (line 16) | struct node
  type node (line 18) | struct node
  type node (line 18) | struct node
  type node (line 19) | struct node
  function printPostorder (line 29) | void printPostorder(struct node* node)
  function printInorder (line 45) | void printInorder(struct node* node)
  function printPreorder (line 61) | void printPreorder(struct node* node)
  function main (line 77) | int main()

FILE: data_structures/binary_search_tree/cpp/BST.h
  function insert (line 22) | void insert(T data) { insert(data, root); }
  function findMin (line 25) | int findMin() { return findMin(root); }
  function remove (line 28) | void remove(T data) { remove(data, root); }
  function find (line 32) | bool find(T data)
  function printTree (line 38) | void printTree()
  type Node (line 47) | struct Node {
  function destroy (line 54) | void destroy(Node *n)
  function print (line 66) | void print(Node *ptr)
  function find (line 84) | bool find(T data, Node *n)
  function findMin (line 99) | int findMin(Node *ptr)
  function Node (line 116) | Node *createLeaf(T data)
  function insert (line 127) | void insert(T data, Node *ptr)
  function removeMatch (line 155) | void removeMatch(Node *parent, Node *match, bool left)
  function removeRootMatch (line 197) | void removeRootMatch()
  function remove (line 231) | void remove(T data, Node *parent)
  type BinarySearchTree (line 262) | typedef BinarySearchTree<int> intBST;

FILE: data_structures/binary_search_tree/java/binary_search_tree.java
  class Node (line 28) | class Node {                                                            ...
    method getLeft (line 34) | public Node getLeft() {
    method setLeft (line 38) | public void setLeft(Node e) {
    method getRight (line 42) | public Node getRight() {
    method setRight (line 46) | public void setRight(Node e) {
    method setValue (line 50) | public void setValue(int value) {
    method getValue (line 54) | public int getValue() {
  class BinarySearchTree (line 65) | public class BinarySearchTree {
    method main (line 67) | public static void main(String[] args){
  class Bintree (line 140) | class Bintree {
    method addLeftChild (line 142) | public boolean addLeftChild(Node parent, int newvalue) {              ...
    method addRightChild (line 151) | public boolean addRightChild(Node parent, int newvalue) {             ...
    method createTree (line 160) | public Node createTree(int[] elements) {                              ...
    method expandTree (line 185) | public boolean expandTree(Node root, int[] elements) {             //e...
    method traverse_inorder (line 215) | public void traverse_inorder(Node root) {                      //inord...
    method traverse_preorder (line 223) | public void traverse_preorder(Node root) {                     //inord...
    method traverse_postorder (line 231) | public void traverse_postorder(Node root) {                    //posto...
  class BinSearchTree (line 240) | class BinSearchTree extends Bintree {                                  /...
    method insert (line 242) | public Node insert(Node root, int key) {                    //define a...
    method createTree (line 255) | @Override
    method addValue (line 268) | public boolean addValue(Node root, int newvalue) { //add value to the ...
    method deleteValue (line 283) | public boolean deleteValue(Node root, int value) {                 //d...
    method searchValue (line 351) | public Node searchValue(Node root, int key) {          //find the node...
    method print_tree (line 365) | public void print_tree(Node root) {

FILE: data_structures/binary_search_tree/java/bst_operations/CheckBST.java
  class CheckBST (line 3) | public class CheckBST {
    method main (line 4) | public static void main(String[] args) {
    method demo (line 8) | private void demo() {
    method isBST (line 20) | private boolean isBST(Node n, int min, int max) {

FILE: data_structures/binary_search_tree/java/bst_operations/CorrectBST.java
  class CorrectBST (line 8) | public class CorrectBST {
    method main (line 9) | public static void main(String[] args) {
    method demo (line 13) | private void demo() {
    method display (line 37) | private void display(Node n) {
    method balanceBST (line 45) | private void balanceBST(Node n, ArrayList<Node> list, int min, int max) {

FILE: data_structures/binary_search_tree/java/bst_operations/FindAncestor.java
  class FindAncestor (line 8) | public class FindAncestor {
    method main (line 9) | public static void main(String[] args) {
    method demo (line 13) | private void demo() {
    method findDistance (line 42) | private int findDistance(Node n, Node ancestor) {
    method findDistanceUtil (line 46) | private int findDistanceUtil(Node n, Node ancestor, int level) {
    method lowestAncestor (line 58) | private Node lowestAncestor(Node n, int m1, int m2) {

FILE: data_structures/binary_search_tree/java/bst_operations/InorderSuccessor.java
  class InorderSuccessor (line 3) | public class InorderSuccessor {
    method main (line 4) | public static void main(String[] args) {
    method demo (line 8) | private void demo() {
    method getNextSuccessor (line 32) | private Integer getNextSuccessor(Node root, Node target) {

FILE: data_structures/binary_search_tree/java/bst_operations/LargestBST.java
  class LargestBST (line 7) | public class LargestBST {
    class BSTCount (line 8) | class BSTCount {
    class BST (line 13) | class BST {
      method BST (line 17) | public BST() {
    method main (line 23) | public static void main(String[] args) {
    method demo (line 27) | private void demo() {
    method largestBST (line 51) | private void largestBST(Node n) {
    method largestBSTUtil (line 59) | private void largestBSTUtil(Node n, BST bst, BSTCount bstCount) {
    method isBST (line 72) | private void isBST(Node n, BSTCount bstCount) {
    method isBSTUtil (line 78) | private Boolean isBSTUtil(Node n, int minValue, int maxValue, BSTCount...

FILE: data_structures/binary_search_tree/java/bst_operations/LevelOrder.java
  class LevelOrder (line 9) | public class LevelOrder {
    method main (line 10) | public static void main(String[] args) {
    method demo (line 14) | private void demo() {
    method displayLevelOrder (line 42) | private void displayLevelOrder(Node n, Boolean zigzag) {
    method print (line 66) | private void print(Deque<Node> parents, Boolean flag, Boolean zigzag) {

FILE: data_structures/binary_search_tree/java/bst_operations/MorrisTraversal.java
  class MorrisTraversal (line 8) | public class MorrisTraversal {
    method main (line 9) | public static void main(String[] args) {
    method demo (line 13) | private void demo() {
    method inorderIterative (line 38) | private void inorderIterative(Node n) {
    method getPredecessor (line 57) | private Node getPredecessor(Node n) {

FILE: data_structures/binary_search_tree/java/bst_operations/Node.java
  class Node (line 3) | public class Node {
    method Node (line 8) | public Node(int d) {

FILE: data_structures/binary_search_tree/java/bst_operations/PathFromRootToNode.java
  class PathFromRootToNode (line 9) | public class PathFromRootToNode {
    method main (line 11) | public static void main(String[] args) {
    method demo (line 15) | private void demo() {
    method display (line 42) | private void display(ArrayList<Node> al) {
    method findPath (line 50) | private void findPath(Node n, int data, ArrayList<Node> al) {

FILE: data_structures/binary_search_tree/javascript/binary_tree.js
  function BST (line 5) | function BST(val) {
  function recurse (line 19) | function recurse(bst) {

FILE: data_structures/binary_search_tree/javascript/binary_tree_search.js
  function recurse (line 6) | function recurse(bst) {
  function recurse (line 23) | function recurse(bst) {

FILE: data_structures/binary_search_tree/javascript/breadth_first_search.js
  method enqueue (line 7) | enqueue(val) {
  method dequeue (line 10) | dequeue() {
  method isEmpty (line 13) | isEmpty() {
  method Top (line 16) | Top() {
  function recurse (line 36) | function recurse(bst) {
  function recurse (line 59) | function recurse(bst) {

FILE: data_structures/binary_search_tree/javascript/depth_first_search.js
  method Top (line 7) | Top() {
  method Pop (line 10) | Pop() {
  method Push (line 13) | Push(val) {
  method isEmpty (line 16) | isEmpty() {
  function recurse (line 33) | function recurse(bst) {
  function recurse (line 49) | function recurse(bst) {

FILE: data_structures/binary_search_tree/python/bst.py
  class TreeNode (line 5) | class TreeNode:
    method __init__ (line 6) | def __init__(self,k=None):
    method isleft (line 12) | def isleft(self):
    method isright (line 19) | def isright(self):
    method isleaf (line 25) | def isleaf(self):
  class BST (line 44) | class BST:
    method __init__ (line 46) | def __init__(self):
    method isEmpty (line 49) | def isEmpty(self):
    method insert (line 54) | def insert(self,key1):
    method maximum (line 76) | def maximum(self):
    method minimum (line 87) | def minimum(self):
    method successor (line 98) | def successor(self,node):
    method predecessor (line 115) | def predecessor(self,node):
    method search (line 134) | def search(self,key):
    method delete (line 145) | def delete(self,node):
  function printree (line 180) | def printree(r):

FILE: data_structures/binary_search_tree/python/bst1.py
  class Node (line 4) | class Node:
    method __init__ (line 5) | def __init__(self,key):
  function insert (line 11) | def insert(root,node):
  function inorder (line 27) | def inorder(root):

FILE: data_structures/binary_search_tree/python/bst2.py
  class Node (line 2) | class Node:
    method __init__ (line 3) | def __init__(self,data,left=None,right=None):
  class BST (line 9) | class BST:
    method __init__ (line 10) | def __init__(self,data=None):
    method printSideway (line 13) | def printSideway(root,level):
    method addI (line 19) | def addI(self,data):
    method insertR (line 39) | def insertR(root,data):
    method inOrder (line 55) | def inOrder(root,lamb=None):
    method _search (line 65) | def _search(root,data):
    method search (line 74) | def search(self,data):
    method _path (line 77) | def _path(root,data):
    method path (line 93) | def path(self,data):
    method _del (line 97) | def _del(root,data):
    method dele (line 106) | def dele(self,data):

FILE: data_structures/binary_tree/c/diameterBT.c
  type node (line 4) | struct node
  type node (line 11) | struct node
  type node (line 17) | struct node
  function diameter (line 20) | int diameter(struct node * tree)
  function height (line 46) | int height(struct node* node)
  type node (line 59) | struct node
  type node (line 61) | struct node
  type node (line 61) | struct node
  type node (line 62) | struct node
  function max (line 71) | int max(int a, int b)
  function main (line 77) | int main()

FILE: data_structures/binary_tree/cpp/binary_tree.cpp
  type Node (line 3) | struct Node {
    method Node (line 8) | Node(int tkey, const std::string& tvalue) : leftnode(nullptr), rightno...
  function query_bst (line 12) | std::string query_bst(const int key) {
  function insert_bst (line 27) | void insert_bst(int key, const std::string& value) {
  function main (line 46) | int main() {

FILE: data_structures/binary_tree/cpp/boundaryTraversal.cpp
  type node (line 5) | struct node
    type node (line 8) | struct node
  function printLeaves (line 12) | void printLeaves(struct node* root)
  function printBoundaryLeft (line 28) | void printBoundaryLeft(struct node* root)
  function printBoundaryRight (line 51) | void printBoundaryRight(struct node* root)
  function printBoundary (line 74) | void printBoundary (struct node* root)
  type node (line 93) | struct node
    type node (line 8) | struct node
  type node (line 95) | struct node
    type node (line 8) | struct node
  type node (line 95) | struct node
    type node (line 8) | struct node
  type node (line 95) | struct node
    type node (line 8) | struct node
  function main (line 104) | int main()

FILE: data_structures/binary_tree/csharp/BinaryTree.cs
  class BinaryTree (line 9) | class BinaryTree
    class TreeObject (line 12) | public class TreeObject
      method TreeObject (line 18) | public TreeObject(TreeObject newitem)
      method getRoot (line 23) | public TreeObject getRoot()
      method getLeftChild (line 28) | public TreeObject getLeftChild()
      method getRightChild (line 33) | public TreeObject getRightChild()
      method setRoot (line 38) | public void setRoot(TreeObject newItem)
      method setLeftChild (line 43) | public void setLeftChild(TreeObject newItem)
      method setRightChild (line 48) | public void setRightChild(TreeObject newItem)
    method init (line 55) | public TreeObject init(TreeObject newitem)
    method insertRight (line 61) | public void insertRight(TreeObject self, TreeObject newNode)
    method insertLeft (line 76) | public void insertLeft(TreeObject self, TreeObject newNode)

FILE: data_structures/binary_tree/java/binary_tree_bfs.java
  class bfs (line 6) | public class bfs {
    method levelOrderQueue (line 8) | public void levelOrderQueue(Node root) {
    method main (line 37) | public static void main(String[] args) throws java.lang.Exception {
  class Node (line 60) | class Node {
    method Node (line 65) | public Node(int data) {

FILE: data_structures/binary_tree/java/binary_tree_dfs.java
  class Node (line 3) | class Node{
    method Node (line 7) | public Node(int item){
  class BinaryTree (line 14) | class BinaryTree{
    method BinaryTree (line 17) | BinaryTree(){
    method preorder_rec (line 22) | public void preorder_rec(Node node){
    method inorder_rec (line 35) | public void inorder_rec(Node node){
    method postorder (line 49) | public void postorder(Node node){
    method main (line 62) | public static void main(String[] args){

FILE: data_structures/binary_tree/python/binary_tree.py
  class BinaryTree (line 1) | class BinaryTree:
    method __init__ (line 2) | def __init__(self,rootObj):
    method insertLeft (line 7) | def insertLeft(self,newNode):
    method insertRight (line 15) | def insertRight(self,newNode):
    method getRightChild (line 24) | def getRightChild(self):
    method getLeftChild (line 27) | def getLeftChild(self):
    method setRootVal (line 30) | def setRootVal(self,obj):
    method getRootVal (line 33) | def getRootVal(self):

FILE: data_structures/bloom_filter/python/bloom_filter.py
  class BloomFilter (line 5) | class BloomFilter:
    method SimpleStringEncode (line 8) | def SimpleStringEncode(self, data):
    method FNV (line 14) | def FNV(self, data):
    method Add (line 23) | def Add(self, data):
    method IsPossiblyIn (line 30) | def IsPossiblyIn(self, data):
    method ComputeCollisionRate (line 37) | def ComputeCollisionRate(self):
    method __init__ (line 43) | def __init__(self):

FILE: data_structures/circular_queue/cpp/circular queue.cpp
  class queue1 (line 5) | class queue1
    method element (line 13) | void element()
    method inqueue (line 19) | void inqueue()
    method dequeue (line 47) | void dequeue()
    method display (line 76) | void display()
  function main (line 85) | int main()

FILE: data_structures/circular_queue/java/circular_queue.java
  type queue1 (line 3) | interface queue1
    method insert (line 5) | void insert();
    method delete (line 6) | void delete();
    method display (line 7) | void display();
  class myqueue1 (line 10) | class myqueue1 implements queue1
    method insert (line 15) | public void insert()
    method delete (line 25) | public void delete()
    method display (line 39) | public void display()
  class tut7 (line 48) | class tut7
    method main (line 50) | public static void main(String args[])

FILE: data_structures/circular_queue/python/circular_queue.py
  class CircularQueue (line 1) | class CircularQueue:
    method __init__ (line 3) | def __init__(self):
    method enqueue (line 9) | def enqueue(self, element):
    method dequeue (line 16) | def dequeue(self):
    method size (line 23) | def size(self):

FILE: data_structures/d_heap/c/d_heap.c
  function HEAP (line 6) | HEAP *init(int d){
  function parent_index (line 15) | int parent_index(int n, int d){
  function child_index (line 19) | int child_index(int n, int d, int i){
  function push (line 23) | void push(HEAP *heap, int value){
  function min_heapify (line 38) | void min_heapify(int n, HEAP *heap){
  function pop (line 56) | int pop(HEAP *heap){
  function short_print (line 70) | void short_print(HEAP *heap){
  function print (line 78) | void print(HEAP *heap){
  function destroy (line 93) | void destroy(HEAP *heap){

FILE: data_structures/dimaeter_of_a_tree/cpp/Diameter.cpp
  type tree (line 5) | struct tree{
    type tree (line 7) | struct tree
  type tree (line 9) | struct tree
    type tree (line 7) | struct tree
  function newnode (line 11) | void newnode(int n)
  function max (line 46) | int max(int a,int b)
  function height (line 53) | int height(node* temp)
  function diameter (line 58) | int diameter(node* temp)
  function main (line 72) | int main()

FILE: data_structures/dimaeter_of_a_tree/java/Diameter.java
  class Diameter (line 4) | class Diameter{
    method Diameter (line 7) | public Diameter(Node root){
    method c_diameter (line 11) | public static int c_diameter(Node node){
    method c_height (line 30) | public static int c_height(Node node){
    method main (line 41) | public static void main(String[] args){

FILE: data_structures/double_linked_list/cpp/doublelinkedlist.cpp
  type student (line 5) | struct student{
  function insertion_begin (line 11) | void insertion_begin(int y){
  function insertion_end (line 30) | void insertion_end(int y){
  function insertion_after (line 48) | void insertion_after(int y1){
  function insertion_before (line 65) | void insertion_before(int y2){
  function FindLocation (line 81) | void FindLocation(int k2){
  function display (line 97) | void display()
  function main (line 106) | int main()

FILE: data_structures/doubly_linked_list/java/DoublyLinkedList.java
  class Node (line 4) | class Node{
    method Node (line 10) | public Node() {  // initialize new node
    method Node (line 17) | public Node(int d) {
    method setNextLink (line 24) | public void setNextLink(Node link) {
    method setPrevLink (line 29) | public void setPrevLink(Node link) {
    method getNextLink (line 34) | public Node getNextLink() {
    method getPrevLink (line 39) | public Node getPrevLink() {
    method getData (line 44) | public int getData() {
  class LinkList (line 51) | class LinkList{
    method LinkList (line 58) | public LinkList() {
    method addAtStart (line 65) | public void addAtStart(int data) {
    method addAtEnd (line 85) | public void addAtEnd(int data) {
    method addAtMiddle (line 106) | public void addAtMiddle(int data , int pos) {
    method addAfterData (line 127) | public void addAfterData(int data , int refData) {
    method deleteNode (line 148) | public void deleteNode(int refData) {
    method showDataFromLeft (line 168) | public void showDataFromLeft() {
    method showDataFromRight (line 181) | public void showDataFromRight() {
  class DoublyLinkedList (line 196) | public class DoublyLinkedList {
    method main (line 198) | public static void main(String[] args) {

FILE: data_structures/doubly_linked_list/python/DoublyLinkedList.py
  class Li2st (line 2) | class Li2st:
    method __init__ (line 4) | def __init__(self,data = None):
    method __str__ (line 7) | def __str__(self):
    method isEmpty (line 15) | def isEmpty(self):
    method append (line 18) | def append(self,data):
    method addHead (line 27) | def addHead(self,data):
    method isIn (line 32) | def isIn(self,data):
    method before (line 42) | def before(self,data):
    method remove (line 60) | def remove(self,index):
    method removeTail (line 63) | def removeTail(self):
    method removeHead (line 68) | def removeHead(self):
    method get (line 71) | def get(self,index):
    method insert (line 80) | def insert(self,node,index):

FILE: data_structures/generic_tree/java/gt.java
  class generictree (line 9) | public class generictree {
    class node (line 10) | private class node {
      method node (line 14) | public node(int data) {
    method generictree (line 23) | public generictree() {
    method takeinput (line 28) | private node takeinput(Scanner scn, node parent, int ithchild) {
    method size (line 46) | public int size() {
    method isempty (line 50) | public boolean isempty() {
    method display (line 54) | public void display() {
    method toString (line 58) | @Override
    method toString (line 63) | private String toString(node node) {
    method max (line 76) | public int max (){
    method max (line 79) | private int max (node Node){
    method find (line 89) | public boolean find(int data){
    method find (line 92) | private boolean find(int data,node Node){
    method height (line 104) | public int height(){
    method height (line 107) | private int height(node node){

FILE: data_structures/graph/cpp/graph.cpp
  class graph (line 7) | class graph
    method graph (line 15) | graph()
    method graph (line 21) | graph(int ver,int e)
    method addedge (line 30) | void addedge(int a,int b,int dir)
    method printedges (line 38) | void printedges()
  function main (line 51) | int main()

FILE: data_structures/graph/python/graph.py
  class vertex (line 1) | class vertex:
    method __init__ (line 2) | def __init__(self,key):
    method addNeighbor (line 6) | def addNeighbor(self,neighbour,weight=0):
    method __str__ (line 9) | def __str__(self):
    method getConnections (line 12) | def getConnections(self):
    method getId (line 15) | def getId(self):
    method getWeight (line 18) | def getWeight(self,nbr):
  class Graph (line 23) | class Graph:
    method __init__ (line 24) | def __init__(self):
    method add_vertex (line 28) | def add_vertex(self,key):
    method get_vertex (line 34) | def get_vertex(self,n):
    method __contains__ (line 40) | def __contains__(self,n):
    method add_edge (line 43) | def add_edge(self,f,t,cost=0):
    method get_vertices (line 50) | def get_vertices(self):
    method __iter__ (line 53) | def __iter__(self):
    method __del__ (line 56) | def __del__(self):

FILE: data_structures/hash_table/cpp/hashtable.h
  function insert (line 30) | void insert(Key key, T val)
  function remove (line 47) | void remove(Key key)
  function T (line 63) | T get(Key key)
  function printTable (line 77) | void printTable()
  function isEmpty (line 96) | inline bool isEmpty() { return used == 0; }
  function contains (line 100) | bool contains(Key key) { return !(get(key) == nullptr); }
  function size (line 103) | inline int size() { return used; }
  function hash (line 113) | size_t hash(Key key) { return (prehash(key) & 0x7fffffff) % length; }

FILE: data_structures/hash_table/csharp/hash_table.cs
  class hTable (line 12) | sealed class hTable // a class
    method add (line 17) | internal void add(string value)
    method delete (line 36) | internal void delete(int key)
    method show (line 48) | internal void show()
  class Program (line 57) | class Program
    method Main (line 59) | static void Main(string[] args)

FILE: data_structures/hash_table/java/Hash_table.java
  class HashTable (line 3) | public class HashTable<K, V> {
    class HTPair (line 4) | private class HTPair {
      method HTPair (line 8) | public HTPair(K key, V value) {
      method equals (line 13) | public boolean equals(Object other) {
      method toString (line 18) | public String toString() {
    method HashTable (line 28) | public HashTable() {
    method HashTable (line 32) | public HashTable(int capacity) {
    method size (line 37) | public int size() {
    method HashFunction (line 41) | private int HashFunction(K key) {
    method put (line 48) | public void put(K key, V value) throws Exception {
    method display (line 74) | public void display() {
    method get (line 84) | public V get(K key) throws Exception {
    method remove (line 101) | public V remove(K key) throws Exception {
    method rehash (line 120) | public void rehash() throws Exception {

FILE: data_structures/hash_table/python/hashTable.py
  class hashTable (line 1) | class hashTable:
    method __init__ (line 2) | def __init__(self):
    method hashfunction (line 7) | def hashfunction(self, key, size): # remainder used to define slots
    method rehash (line 10) | def rehash(self, oldhash, size): # just a simple linear probing functi...
    method insert (line 13) | def insert(self, key, data):
    method get (line 28) | def get(self, key):
    method __getitem__ (line 45) | def __getitem__(self,key):
    method __setitem__ (line 48) | def __setitem__(self,key,data):

FILE: data_structures/hashmap/java/hashmap.java
  class hashmap (line 2) | class hashmap {
    method main (line 4) | public static void main(String args[]) {

FILE: data_structures/hashset/java/hashset.java
  class hashset (line 2) | class hashset {
    method main (line 4) | public static void main(String args[]) {

FILE: data_structures/heap/cpp/MinHeap.h
  function class (line 5) | class MinHeap
  function push (line 35) | void MinHeap::push(int element)
  function pop (line 41) | int MinHeap::pop()
  function siftUp (line 51) | void MinHeap::siftUp(int index)
  function siftDown (line 64) | void MinHeap::siftDown(int index)
  function left (line 82) | int MinHeap::left(int parent)
  function right (line 88) | int MinHeap::right(int parent)
  function parent (line 94) | int MinHeap::parent(int child)

FILE: data_structures/heap/java/Heap.java
  class Heap (line 5) | public class Heap<T extends Comparable<T>> {
    method Heap (line 9) | public Heap(){
    method Heap (line 13) | public Heap(boolean isMin){
    method Heap (line 18) | public Heap(T[] arr,boolean isMin){
    method size (line 29) | public int size(){
    method getHP (line 33) | public T getHP(){
    method add (line 37) | public void add(T item){
    method upheapify (line 42) | private void upheapify(int ci){
    method swap (line 55) | private void swap(int i,int j){
    method isLarger (line 61) | private boolean isLarger(int i,int j){
    method remove (line 71) | public T remove(){
    method downheapify (line 79) | private void downheapify(int pi){
    method display (line 95) | public void display(){
    method display (line 99) | private void display(int index){

FILE: data_structures/heap/java/heaps.java
  class heaps (line 5) | public class heaps<k extends Comparable<k>, v> {
    class node (line 6) | private class node implements Comparable<node> {
      method node (line 10) | node(k score, v value) {
      method toString (line 15) | public String toString() {
      method compareTo (line 19) | @Override
    method heaps (line 32) | public heaps() {
    method heaps (line 36) | public heaps(boolean ismin) {
    method size (line 41) | public int size() {
    method isempty (line 45) | public boolean isempty() {
    method add (line 49) | public void add(k score, v value) {
    method upheapify (line 55) | private void upheapify(int ci) {
    method removehp (line 68) | public v removehp() {
    method downheapify (line 76) | private void downheapify(int pi) {
    method gethp (line 91) | public v gethp() {
    method display (line 95) | public void display() {
    method toString (line 99) | public String toString() {
    method displaytree (line 103) | public void displaytree() {
    method treestring (line 108) | private String treestring(int pi) {
    method swap (line 131) | private void swap(int i, int j) {

FILE: data_structures/heap/python/minheap.py
  class Heap (line 3) | class Heap(object):
    method __init__ (line 4) | def __init__(self):
    method push (line 7) | def push(self, priority, item):
    method pop (line 11) | def pop(self):
    method __len__ (line 15) | def __len__(self):
    method __iter__ (line 18) | def __iter__(self):
    method next (line 21) | def next(self):

FILE: data_structures/heap/ruby/heap.rb
  class Heap (line 1) | class Heap
    method initialize (line 2) | def initialize
    method push (line 6) | def push(data)
    method top (line 11) | def top
    method pop (line 15) | def pop
    method size (line 26) | def size
    method tear_up (line 32) | def tear_up(pos)
    method tear_down (line 42) | def tear_down(pos)

FILE: data_structures/heapify_insert_extract_min/cpp/max-heap_functions.cpp
  function main (line 18) | int main()
  function heapify (line 115) | void heapify(int k,int arr[])
  function insert (line 146) | void insert(int t,int arr[])
  function extract_max (line 161) | int extract_max(int arr[])

FILE: data_structures/left_learning_red_black_tree/c/llrb_tree.c
  type treenode (line 6) | struct treenode
  type TREENODE (line 15) | typedef struct treenode TREENODE;
  type TREENODE (line 16) | typedef TREENODE *TREE;
  function main (line 32) | int main()
  function TREE (line 64) | TREE make_tree(int data, TREE left, TREE right)
  function is_red (line 77) | bool is_red(TREE t)
  function is_empty (line 85) | int is_empty(TREE t)
  function TREE (line 90) | TREE left_subtree(TREE t)
  function TREE (line 95) | TREE right_subtree(TREE t)
  function size (line 100) | size_t size(TREE t)
  function max (line 111) | size_t max(size_t x, size_t y)
  function height (line 117) | size_t height(TREE t)
  function preorder (line 127) | void preorder(TREE t)
  function inorder (line 137) | void inorder(TREE t)
  function postorder (line 147) | void postorder(TREE t)
  function print_leaf (line 157) | void print_leaf(TREE t)
  function rotate_left (line 171) | void rotate_left(TREE *t)
  function rotate_right (line 186) | void rotate_right(TREE *t)
  function flip_color (line 201) | void flip_color(TREE *t)
  function insert_RB (line 208) | void insert_RB(TREE *t, int data)
  function search_RB (line 229) | int search_RB(TREE t, int key)

FILE: data_structures/left_learning_red_black_tree/java/left_leaning_red_black_tree.java
  class left_leaning_red_black_tree (line 2) | public class left_leaning_red_black_tree<Key extends Comparable<Key>, Va...
    class Node (line 7) | private class Node {
      method Node (line 12) | Node(Key key, Value val) {
    method search (line 19) | public Value search(Key key) {
    method insert (line 30) | public void insert(Key key, Value value) {
    method insert (line 35) | private Node insert(Node h, Key key, Value value) {
    method isRed (line 47) | private boolean isRed(Node h) {
    method colorFlip (line 52) | void colorFlip(Node h) {
    method rotateLeft (line 58) | private Node rotateLeft(Node h) {
    method rotateRight (line 67) | private Node rotateRight(Node h) {
    method preorder (line 76) | public void preorder() {
    method preorder (line 80) | private void preorder(Node root) {
    method inorder (line 87) | public void inorder() {
    method inorder (line 91) | private void inorder(Node root) {
    method postorder (line 98) | public void postorder() {
    method postorder (line 102) | private void postorder(Node root) {
    method main (line 109) | public static void main(String[] args) {

FILE: data_structures/linked_list/c/linked_list.c
  type node (line 5) | struct node
  function main (line 11) | int main()
  function create (line 41) | void create()
  function insert (line 68) | void insert()
  function delete (line 110) | void delete()
  function search (line 149) | void search()
  function display (line 175) | void display()

FILE: data_structures/linked_list/cpp/LinkedList.cpp
  type node (line 11) | struct node
    type node (line 14) | struct node
  class single_llist (line 20) | class single_llist
    method single_llist (line 33) | single_llist()
  function main (line 42) | main()
  function node (line 123) | node *single_llist::create_node(int value)
    type node (line 14) | struct node
  type node (line 148) | struct node
    type node (line 14) | struct node
  type node (line 172) | struct node
    type node (line 14) | struct node
  type node (line 192) | struct node
    type node (line 14) | struct node
  type node (line 239) | struct node
    type node (line 14) | struct node
  type node (line 275) | struct node
    type node (line 14) | struct node
  type node (line 322) | struct node
    type node (line 14) | struct node
  type node (line 358) | struct node
    type node (line 14) | struct node
  type node (line 379) | struct node
    type node (line 14) | struct node
  type node (line 409) | struct node
    type node (line 14) | struct node

FILE: data_structures/linked_list/cpp/singly_linked_list.cpp
  type std (line 2) | namespace std{
    class Node (line 4) | class Node{
      method Node (line 10) | Node(){}
      method setData (line 12) | void setData(int Data){ _data = Data;}
      method setNext (line 13) | void setNext(Node *Next){
      method Data (line 20) | int Data(){return _data;}
      method Node (line 21) | Node *Next(){return _next;}
    class LinkedList (line 24) | class LinkedList{
      method LinkedList (line 28) | LinkedList(){ head = NULL;}
  function main (line 115) | int main(){

FILE: data_structures/linked_list/csharp/LinkedList.cs
  class LinkedList (line 13) | class LinkedList
    class LinkedListNode (line 19) | public class LinkedListNode
      method LinkedListNode (line 24) | public LinkedListNode(object newitem)
      method LinkedListNode (line 29) | public LinkedListNode(object newitem, LinkedListNode next)
      method getData (line 35) | public object getData()
      method getNextNode (line 40) | public LinkedListNode getNextNode()
      method setNextNode (line 45) | public void setNextNode(LinkedListNode next)
    method LinkedList (line 53) | public LinkedList(object data)
    method addFirst (line 59) | public void addFirst(object data)
    method addLast (line 65) | public void addLast(object data)
    method insertAfter (line 83) | public void insertAfter(object data, object newData)
    method insertBefore (line 98) | public void insertBefore(object data, object newData)
    method remove (line 126) | public void remove(object data)

FILE: data_structures/linked_list/go/linked_list.go
  type Node (line 5) | type Node struct
    method Next (line 10) | func (n *Node) Next() *Node {
  type LinkedList (line 14) | type LinkedList struct
    method Add (line 19) | func (l *LinkedList) Add(v interface{}) {
    method First (line 31) | func (l *LinkedList) First() *Node {
    method ToString (line 35) | func (l *LinkedList) ToString() string {
  function main (line 48) | func main() {

FILE: data_structures/linked_list/java/LinkedList.java
  class Node (line 8) | class Node
    method Node (line 14) | public Node()
    method Node (line 20) | public Node(int d,Node n)
    method setLink (line 26) | public void setLink(Node n)
    method setData (line 31) | public void setData(int d)
    method getLink (line 36) | public Node getLink()
    method getData (line 41) | public int getData()
  class linkedList (line 48) | class linkedList
    method linkedList (line 55) | public linkedList()
    method isEmpty (line 62) | public boolean isEmpty()
    method getSize (line 67) | public int getSize()
    method insertAtStart (line 72) | public void insertAtStart(int val)
    method insertAtEnd (line 88) | public void insertAtEnd(int val)
    method insertAtPos (line 104) | public void insertAtPos(int val , int pos)
    method deleteAtPos (line 123) | public void deleteAtPos(int pos)
    method display (line 161) | public void display()
  class SinglyLinkedList (line 187) | public class SinglyLinkedList
    method main (line 189) | public static void main(String[] args)

FILE: data_structures/linked_list/java/LinkedListLinkedList.java
  class LinkedList (line 7) | public class LinkedList<E> {
    method LinkedList (line 15) | public LinkedList(){
    method add (line 25) | public boolean add(E element){
    method remove (line 50) | public boolean remove(E element){
    method contains (line 68) | public boolean contains(E element) {
    method head (line 83) | public E head(){
    method tail (line 91) | public E tail(){
    method size (line 99) | public int size(){
    class Node (line 108) | private class Node{
      method Node (line 113) | public Node(E element){

FILE: data_structures/linked_list/java/LinkedListTest.java
  class LinkedListTest (line 10) | public class LinkedListTest {
    method testLinkedList (line 11) | @Test

FILE: data_structures/linked_list/python/linked_list.py
  class Node (line 1) | class Node:
    method __init__ (line 2) | def __init__(self, data=None, next_node=None):
    method __repr__ (line 7) | def __repr__(self):
  class LinkedList (line 11) | class LinkedList:
    method __init__ (line 16) | def __init__(self, data_iterable):
    method add (line 21) | def add(self, data):
    method search (line 28) | def search(self, data):
    method remove (line 36) | def remove(self, node):
    method __repr__ (line 44) | def __repr__(self):

FILE: data_structures/linked_list/ruby/linked_list.rb
  class Node (line 1) | class Node
    method initialize (line 5) | def initialize(data, next_node = nil)
  class LinkedList (line 11) | class LinkedList
    method initialize (line 12) | def initialize
    method insertFront (line 17) | def insertFront(data)
    method insertBack (line 23) | def insertBack(data)
    method find (line 30) | def find(data)
    method remove (line 39) | def remove(node)
    method iterate (line 60) | def iterate

FILE: data_structures/linked_list_queue/cpp/queue_linked_list.cpp
  type QueueNode (line 6) | struct QueueNode {
  class CQueue (line 19) | class CQueue {
    method enqueue (line 27) | void enqueue(T value) {
    method T (line 39) | T dequeue() {
    method isEmpty (line 52) | bool isEmpty() {
  function main (line 63) | int main() {

FILE: data_structures/min_heap/cpp/impl_minHeap.cpp
  function main (line 16) | int main(){

FILE: data_structures/min_heap/cpp/minHeap.cpp
  function getLeftIndex (line 15) | int getLeftIndex(int x){
  function getRightIndex (line 19) | int getRightIndex(int x){
  function getParentIndex (line 23) | int getParentIndex(int x){

FILE: data_structures/min_heap/cpp/minHeap.hpp
  class MinHeap (line 10) | class MinHeap{

FILE: data_structures/mirror_of_a_tree.java/java/Mirror.java
  class Mirror (line 1) | class Mirror{
    method mirror (line 5) | public void mirror(Node node){
    method printTree (line 19) | public void printTree(Node node){
    method main (line 30) | public static void main(String[] args){

FILE: data_structures/mirrot_of_a_tree.cpp/mirror.cpp
  type btree (line 7) | struct btree {
    type btree (line 9) | struct btree
    type btree (line 10) | struct btree
  function btree (line 13) | btree *makeTree(btree *root , int d) {
    type btree (line 9) | struct btree
    type btree (line 10) | struct btree
  function btree (line 42) | btree *mirror(btree *root) {
    type btree (line 9) | struct btree
    type btree (line 10) | struct btree
  function printTreeLevelOrder (line 53) | void printTreeLevelOrder(btree *root) {
  function main (line 66) | int main()

FILE: data_structures/mst/cpp/mst.cpp
  function minKey (line 12) | int minKey(int key[], bool mstSet[])
  function printMST (line 25) | int printMST(int parent[], int n, int graph[V][V])
  function primMST (line 34) | void primMST(int graph[V][V])
  function main (line 76) | int main()

FILE: data_structures/mst/java/prims.java
  class PrimMST (line 1) | public class PrimMST {
    method PrimMST (line 13) | public PrimMST(EdgeWeightedGraph G) {
    method prim (line 29) | private void prim(EdgeWeightedGraph G, int s) {
    method scan (line 39) | private void scan(EdgeWeightedGraph G, int v) {
    method edges (line 58) | public Iterable<Edge> edges() {
    method weight (line 73) | public double weight() {
    method check (line 82) | private boolean check(EdgeWeightedGraph G) {
    method main (line 145) | public static void main(String[] args) {

FILE: data_structures/priority_queue/c/priority_queue.cpp
  type node (line 3) | struct node{
    type node (line 5) | struct node
  type node (line 7) | struct node
    type node (line 5) | struct node
  function enque (line 9) | void enque(int data,int priority)
  function deque (line 19) | void deque()
  function display (line 45) | void display()
  function main (line 61) | int main()

FILE: data_structures/queue/c/queue.c
  function main (line 7) | int main()
  function push (line 33) | void push()
  function pop (line 49) | void pop()
  function display (line 61) | void display()

FILE: data_structures/queue/cpp/Queue.cpp
  function T (line 32) | T* Queue<T>::Front()

FILE: data_structures/queue/cpp/Queue.h
  type Node (line 9) | struct Node

FILE: data_structures/queue/csharp/Queue.cs
  class Queue (line 9) | class Queue
    method dequeue (line 14) | public Object dequeue()
    method peek (line 29) | public Object peek()
    method enqueue (line 42) | public void enqueue(Object newItem)
    method isEmpty (line 48) | public bool isEmpty()

FILE: data_structures/queue/go/queue.go
  type queue (line 5) | type queue struct
    method Enqueue (line 13) | func (q *queue) Enqueue(value interface{}) {
    method Dequeue (line 17) | func (q *queue) Dequeue() (interface{}) {
  function NewQueue (line 9) | func NewQueue() queue {
  function main (line 23) | func main() {

FILE: data_structures/queue/java/IterableQueue.java
  class IterableQueue (line 4) | public class IterableQueue<E> implements Iterable<E> {
    class Node (line 10) | private static class Node<E> {
    method IterableQueue (line 18) | public IterableQueue() {
    method isEmpty (line 29) | public boolean isEmpty() {
    method size (line 38) | public int size() {
    method peek (line 48) | public E peek() {
    method enqueue (line 58) | public void enqueue(E element) {
    method dequeue (line 74) | public E dequeue() {
    method toString (line 88) | public String toString() {
    method iterator (line 102) | public Iterator<E> iterator()  {
    class ListIterator (line 107) | private class ListIterator<Item> implements Iterator<Item> {
      method ListIterator (line 110) | public ListIterator(Node<Item> first) {
      method hasNext (line 114) | public boolean hasNext()  { return current != null;                 ...
      method remove (line 115) | public void remove()      { throw new UnsupportedOperationException(...
      method next (line 117) | public Item next() {

FILE: data_structures/queue/javascript/queue_ES5.js
  function Queue (line 1) | function Queue() {

FILE: data_structures/queue/javascript/queue_ES6.js
  class Queue (line 1) | class Queue {
    method constructor (line 2) | constructor() {
    method size (line 8) | size() {
    method enqueue (line 12) | enqueue(data) {
    method dequeue (line 17) | dequeue() {

FILE: data_structures/queue/php/queue.php
  class Queue (line 8) | class Queue {
    method __construct (line 18) | public function __construct($data = null){
    method size (line 29) | public function size(){
    method enqueue (line 36) | public function enqueue($item){
    method dequeue (line 44) | public function dequeue(){

FILE: data_structures/queue/python/queue_two_stacks.py
  function get_command (line 1) | def get_command():
  class Stack (line 15) | class Stack:
    method __init__ (line 16) | def __init__(self):
    method __len__ (line 19) | def __len__(self):
    method push (line 22) | def push(self, data):
    method pop (line 25) | def pop(self):
    method top (line 28) | def top(self):
  class Queue (line 34) | class Queue:
    method __init__ (line 35) | def __init__(self):
    method enqueue (line 39) | def enqueue(self, data):
    method dequeue (line 42) | def dequeue(self):
    method peek (line 48) | def peek(self):
    method _tail_to_head (line 54) | def _tail_to_head(self):
  function main (line 61) | def main():

FILE: data_structures/queue/ruby/queue.rb
  class Queue (line 1) | class Queue
    method initialize (line 2) | def initialize
    method enqueue (line 6) | def enqueue(data)
    method dequeue (line 10) | def dequeue()
    method front (line 15) | def front()
    method back (line 20) | def back()
    method size (line 24) | def size()

FILE: data_structures/simple_queue/java/QueueImplementation.java
  class QueueImplementation (line 4) | public class QueueImplementation
    method main (line 6) | public static void main(String[] args)

FILE: data_structures/simple_queue/java/arrayQueue.java
  class arrayQueue (line 8) | class arrayQueue {
    method arrayQueue (line 13) | public arrayQueue(int n)
    method isEmpty (line 22) | public boolean isEmpty()
    method isFull (line 27) | public boolean isFull()
    method getSize (line 32) | public int getSize()
    method peek (line 37) | public int peek()
    method insert (line 44) | public void insert(int i)
    method remove (line 59) | public int remove()
    method display (line 78) | public void display()

FILE: data_structures/simple_queue/java/queue.java
  type queue (line 2) | interface queue
    method insert (line 4) | void insert();
    method delete (line 5) | void delete();
    method display (line 6) | void display();
  class myqueue (line 9) | class myqueue implements queue
    method insert (line 14) | public void insert()
    method delete (line 27) | public void delete()
    method display (line 39) | public void display()
  class tut6 (line 48) | class tut6
    method main (line 50) | public static void main(String args[])

FILE: data_structures/simple_queue/python/queue.py
  class Queue (line 1) | class Queue:
    method __init__ (line 2) | def __init__(self):
    method enqueue (line 5) | def enqueue(self, item):
    method dequeue (line 8) | def dequeue(self):
    method peek (line 11) | def peek(self):

FILE: data_structures/stack/c#/main.cs
  class main (line 4) | public class main{
    method Main (line 5) | static void Main(){

FILE: data_structures/stack/c#/stack.cs
  class Stack (line 5) | public class Stack<t>  {
    method Stack (line 10) | public Stack(){
    method Push (line 17) | public void Push(t data){
    method Pop (line 22) | public void Pop(){
    method Top (line 25) | public t Top(){

FILE: data_structures/stack/c/stack1.c
  type node (line 5) | struct node{
  type node (line 10) | struct node
  function insertatthebegin (line 11) | void insertatthebegin(int x)
  function print (line 21) | void print()
  function reverse (line 39) | void reverse()
  function main (line 57) | int main()

FILE: data_structures/stack/cpp/celement.h
  type CElement (line 7) | struct CElement {

FILE: data_structures/stack/cpp/cstack.h
  function class (line 8) | class CStack

FILE: data_structures/stack/cpp/cstack.test.cpp
  function main (line 6) | int main()

FILE: data_structures/stack/cpp/stack_balanced_paranthesis.cpp
  function main (line 6) | int main()

FILE: data_structures/stack/cpp/templated_stack.cpp
  function main (line 12) | int main(void) {

FILE: data_structures/stack/cpp/templated_stack.hpp
  class Stack (line 12) | class Stack {
    class Node (line 14) | class Node {
      method Node (line 20) | Node(const Object & d, Node * n):
    method Stack (line 29) | Stack() {  }
    method size (line 33) | int size() {
    method push (line 38) | void push(const Object & value) {
    method Object (line 44) | Object top() {
    method pop (line 51) | void pop() {
    method empty (line 63) | bool empty() {
    method clear (line 68) | void clear() {

FILE: data_structures/stack/csharp/Stack.cs
  class Stack (line 9) | class Stack
    method pop (line 13) | public Object pop()
    method push (line 28) | public void push(Object newItem)
    method isEmpty (line 34) | public bool isEmpty()

FILE: data_structures/stack/go/stack.go
  type stack (line 3) | type stack struct
    method Push (line 7) | func (s *stack) Push(value interface{}) {
    method Pop (line 11) | func (s *stack) Pop() interface{} {

FILE: data_structures/stack/java/Node.java
  class Node (line 3) | public class Node<T>{
    method Node (line 9) | public Node(T data){
    method Node (line 16) | public Node(){
    method getData (line 23) | public T getData(){
    method setData (line 27) | public void setData(T data){
    method getIndex (line 31) | public int getIndex(){
    method setNext (line 35) | public void setNext(Node node){
    method getNext (line 39) | public Node getNext(){
    method setPreview (line 43) | public void setPreview(Node node){
    method getPreview (line 47) | public Node getPreview(){

FILE: data_structures/stack/java/Stack.java
  class Stack (line 3) | public class Stack<T>{
    method Stack (line 7) | public Stack(){
    method isEmpty (line 12) | public boolean isEmpty(){
    method push (line 16) | public void push(T data){
    method top (line 29) | public T top(){
    method pop (line 36) | public void pop(){
    method viewStack (line 51) | public void viewStack(){
    method main (line 63) | public static void main(String[] args) {

FILE: data_structures/stack/java/integer_stack.java
  class Stack (line 4) | public class Stack {
    method Stack (line 7) | public Stack(){
    method Push (line 10) | public void Push(int val){
    method Pop (line 15) | public void Pop(){
    method Top (line 22) | public int Top(){
    method isEmpty (line 25) | private boolean isEmpty(){

FILE: data_structures/stack/javascript/stack.js
  function Stack (line 2) | function Stack(maxSize = null) {

FILE: data_structures/stack/php/stack.php
  class Stack (line 2) | class Stack {
    method Pop (line 5) | public function Pop(){
    method Push (line 12) | public function Push($data) {
    method Top (line 17) | public function Top(){

FILE: data_structures/stack/python/stack.py
  class Stack (line 1) | class Stack:
    method __init__ (line 2) | def __init__(self):
    method push (line 5) | def push(self, item):
    method pop (line 8) | def pop(self):
    method peek (line 11) | def peek(self):

FILE: data_structures/stack/ruby/stack.rb
  class Stack (line 1) | class Stack
    method initialize (line 2) | def initialize
    method push (line 6) | def push(data)
    method pop (line 10) | def pop()
    method top (line 15) | def top()
    method size (line 20) | def size()

FILE: data_structures/treemap/java/treemap.java
  class treemap (line 2) | class treemap {
    method main (line 4) | public static void main(String args[]) {

FILE: data_structures/treeset/java/treeset.java
  class treeset (line 2) | class treeset {
    method main (line 4) | public static void main(String args[]) {

FILE: data_structures/trie/java/Trie.java
  class Trie (line 3) | public class Trie {
    class TrieNode (line 4) | public class TrieNode {
      method TrieNode (line 8) | public TrieNode() {
    method main (line 13) | public static void main(String[] args) {
    method demo (line 17) | private void demo() {
    method displayTree (line 32) | private void displayTree(TrieNode trie) {
    method DFS (line 41) | private void DFS(TrieNode n, StringBuilder sb, int index) {
    method add (line 56) | private void add(TrieNode trie, String s) {
    method getCharacter (line 68) | public Character getCharacter(int index) {
    method getIndex (line 72) | public Integer getIndex(Character c) {

FILE: data_structures/trie/javascript/Trie.js
  class Node (line 1) | class Node {
    method constructor (line 2) | constructor(){
    method setEnd (line 7) | setEnd(isEnd) {
    method addChild (line 11) | addChild(value) {
  class Trie (line 22) | class Trie {
    method constructor (line 23) | constructor() {
    method findPrefix (line 27) | findPrefix(prefix, parent) {
    method addWord (line 42) | addWord(word, parent = this.root) {
    method list (line 54) | list(root = this.root, word = [], words = []) {

FILE: data_structures/union_find/cpp/UnionFind.cpp
  class UnionFind (line 5) | class UnionFind{
    method root (line 11) | int root(int p){
    method UnionFind (line 22) | UnionFind(int N){
    method unionElem (line 31) | void unionElem(int p, int q){
    method connected (line 47) | bool connected(int p, int q){
    method getComponents (line 52) | int getComponents(){
  function main (line 57) | int main(){

FILE: data_structures/union_find/java/UnionFind.java
  class UnionFind (line 2) | class UnionFind{
    method UnionFind (line 8) | public UnionFind(int n){
    method root (line 19) | private int root(int p){
    method union (line 28) | public void union(int p, int q){
    method connected (line 44) | public boolean connected(int p, int q){
    method getComponents (line 49) | public int getComponents(){
  class Main (line 54) | class Main {
    method main (line 55) | public static void main(String[] args){

FILE: data_structures/union_find/python/UnionFind.py
  function find (line 2) | def find(data, i):
  function union (line 8) | def union(data, i, j):
  function connected (line 14) | def connected(data, i, j):