SYMBOL INDEX (487 symbols across 93 files)

FILE: C02-Getting-Started/exercise_code/Insertion_sort_with_binary_search.py
  function insertion_sort (line 9) | def insertion_sort(array):
  function insertion_sort_v2 (line 18) | def insertion_sort_v2(array):
  function binary_search (line 27) | def binary_search(array, searchingelement, arraypart):

FILE: C02-Getting-Started/exercise_code/binary-search.py
  function binary_search (line 10) | def binary_search(array, searchingelement):

FILE: C02-Getting-Started/exercise_code/inversions.cpp
  function MergeWithCountInversions (line 8) | void MergeWithCountInversions(vector<int>& v, int p, int q, int r, int& ...
  function MergeSort (line 29) | void MergeSort(vector<int>& v, int p, int r, int& cnt) {
  function main (line 37) | int main(int argc, const char * argv[]) {

FILE: C02-Getting-Started/exercise_code/inversions.py
  function merge (line 4) | def merge(items, p, q, r):
  function mergesort (line 25) | def mergesort(items, p, r):

FILE: C02-Getting-Started/exercise_code/merge-sort.py
  function merge (line 5) | def merge(items, p, q, r):
  function mergesort (line 23) | def mergesort(items, p, r):

FILE: C04-Recurrences/exercise_code/findIndex.py
  function mergeindex (line 5) | def mergeindex(items, evens):
  function findindex (line 32) | def findindex(items):

FILE: C04-Recurrences/exercise_code/findMissing.py
  function findmissing (line 4) | def findmissing(items, i) :

FILE: C05-Probabilistic-Analysis-and-Randomized-Algorithms/myrandom.py
  function _m_random (line 10) | def _m_random(b):
  function m_random (line 19) | def m_random(a, b):
  function main (line 22) | def main():

FILE: C06-Heapsort/d-ary-heaps.cpp
  function max_heapify (line 22) | void max_heapify(heap_t *heap, int i) {
  function extract_max (line 38) | int extract_max(heap_t *heap) {
  function increase_key (line 46) | void increase_key(heap_t *heap, int i, int key) {
  function insert (line 60) | void insert(heap_t *heap, int key) {

FILE: C06-Heapsort/heap.cpp
  function parent (line 14) | int parent(int i)
  function left (line 22) | int left(int i)
  function right (line 30) | int right(int i)
  function maxHeapify (line 38) | void maxHeapify(int A[], int n, int i)
  function buildMaxHeap (line 59) | void buildMaxHeap(int A[], int n)
  function heapsort (line 69) | void heapsort(int A[], int n)
  function print (line 79) | void print(int A[], int n)
  function main (line 87) | int main()

FILE: C06-Heapsort/main.cpp
  function main (line 21) | int main()

FILE: C06-Heapsort/p_queue.h
  function class (line 14) | class p_queue

FILE: C06-Heapsort/young.cpp
  function EXTRACT_MIN (line 13) | int EXTRACT_MIN(vector<vector<int> > &young)
  function INSERT (line 43) | void INSERT(vector<vector<int> > &young, int v)
  function EXIST (line 69) | bool EXIST(vector<vector<int> > &young, int v)
  function print_young (line 88) | void print_young(vector<vector<int> > &young)
  function main (line 101) | int main() {

FILE: C07-Quicksort/exercise_code/fuzzy_sort.py
  function intersects (line 6) | def intersects(a, b):
  function before (line 9) | def before(a, b):
  function partition (line 12) | def partition(items, p, r):
  function fuzzy_sort (line 44) | def fuzzy_sort(items, p, r):

FILE: C07-Quicksort/exercise_code/hoare.py
  function quicksort (line 4) | def quicksort(items, p, r):
  function partition (line 10) | def partition(items, p, r):

FILE: C07-Quicksort/exercise_code/quickSortWithEqualElements.cpp
  class QuickSort (line 10) | class QuickSort{
    method QuickSort (line 12) | QuickSort(){}
  function main (line 177) | int main(){

FILE: C07-Quicksort/exercise_code/quicksort.py
  function quicksort (line 4) | def quicksort(items, p, r):
  function partition (line 10) | def partition(items, p, r):

FILE: C07-Quicksort/exercise_code/tailrecursive.py
  function tail_quicksort (line 4) | def tail_quicksort(items, p, r):
  function partition (line 14) | def partition(items, p, r):

FILE: C07-Quicksort/quicksort.py
  function quicksort (line 4) | def quicksort(items, p, r):
  function partition (line 10) | def partition(items, p, r):

FILE: C07-Quicksort/randomized-quicksort.py
  function randomized_quicksort (line 6) | def randomized_quicksort(items, p, r):
  function randomized_partition (line 12) | def randomized_partition(items, p, r):
  function partition (line 17) | def partition(items, p, r):

FILE: C08-Sorting-in-Linear-Time/exercise_code/in_place_counting_sort.py
  function in_place_counting_sort (line 4) | def in_place_counting_sort(items, k):

FILE: C08-Sorting-in-Linear-Time/exercise_code/intergerQuery.cpp
  class IntegerQuery (line 8) | class IntegerQuery{
  function main (line 43) | int main(){

FILE: C08-Sorting-in-Linear-Time/exercise_code/radixSort.cpp
  class RandInt (line 13) | class RandInt{
    method RandInt (line 16) | RandInt(int low, int high): ge(chrono::system_clock::now().time_since_...
  class RadixSort (line 24) | class RadixSort{
  function main (line 91) | int main(){

FILE: C08-Sorting-in-Linear-Time/exercise_code/water-jugs.py
  function match (line 5) | def match(reds, blues):

FILE: C09-Medians-and-Order-Statistics/exercise_code/k-close2median.py
  function k_close2median (line 5) | def k_close2median(items, k):
  function select (line 21) | def select(items, n):
  function median (line 33) | def median(items):

FILE: C09-Medians-and-Order-Statistics/exercise_code/k-quantile.py
  function k_quantiles (line 6) | def k_quantiles(items, k):
  function median_index (line 32) | def median_index(n):
  function partition (line 38) | def partition(items, element):
  function select (line 53) | def select(items, n):

FILE: C09-Medians-and-Order-Statistics/exercise_code/randomized-select-iterative.cpp
  class Solution (line 12) | class Solution {
    method partition (line 14) | int partition(int arr[], int l, int r) {
    method randomPartition (line 26) | int randomPartition(int arr[], int l, int r) {
    method kthSmallest (line 35) | int kthSmallest(int arr[], int l, int r, int k) {
  function main (line 53) | int main() {

FILE: C09-Medians-and-Order-Statistics/exercise_code/second-smallest.cpp
  type Node (line 12) | struct Node
    method Node (line 18) | Node() : v(-1),left(nullptr),right(nullptr){}
    method Node (line 19) | Node(int _v, bool d) : v(_v),left(nullptr),right(nullptr),dir(d){}
  function second_smallest_element (line 23) | int second_smallest_element(int arr[], int n)
  function main (line 84) | int main() {

FILE: C09-Medians-and-Order-Statistics/minmax.c
  function minmax (line 13) | void minmax(int *arr, int n, int *maximum, int *minium)
  function main (line 46) | int main()

FILE: C09-Medians-and-Order-Statistics/problems/i-largest.cpp
  function findMedian (line 20) | int findMedian(int arr[], int n)
  function kthSmallest (line 28) | int kthSmallest(int arr[], int l, int r, int k)
  function swap (line 64) | void swap(int *a, int *b)
  function partition (line 73) | int partition(int arr[], int l, int r, int x)
  function main (line 95) | int main()

FILE: C09-Medians-and-Order-Statistics/problems/i-largest.py
  function sort1 (line 6) | def sort1(items, i):
  function sort2 (line 10) | def sort2(items, i):

FILE: C09-Medians-and-Order-Statistics/problems/weighted_median.py
  function select (line 5) | def select(items, n):
  function median (line 17) | def median(items):
  function weighted_median (line 63) | def weighted_median(items, w_items, start, end):

FILE: C09-Medians-and-Order-Statistics/randomized-select.cpp
  function partition (line 5) | int partition(vector<int>& arr, int l, int r) {
  function randomPartition (line 17) | int randomPartition(vector<int>& arr, int l, int r) {
  function kthSmallest (line 24) | int kthSmallest(vector<int>& arr, int l, int r, int k) {
  function kthSmallest (line 35) | int kthSmallest(vector<int>& arr, int k) {
  function main (line 40) | int main() {

FILE: C09-Medians-and-Order-Statistics/worst-case-linear-time.cpp
  function findMedian (line 20) | int findMedian(int arr[], int n)
  function kthSmallest (line 28) | int kthSmallest(int arr[], int l, int r, int k)
  function swap (line 64) | void swap(int *a, int *b)
  function partition (line 73) | int partition(int arr[], int l, int r, int x)
  function main (line 95) | int main()

FILE: C10-Elementary-Data-Structures/exercise_code/af-obj.c
  type list_t (line 6) | typedef int list_t;
  type obj_t (line 7) | typedef int obj_t;
  function init_storage (line 17) | void init_storage() {
  function list_t (line 26) | list_t allocate_object() {
  function free_object (line 37) | void free_object(list_t list) {
  function list_t (line 42) | list_t cons(obj_t key, list_t list) {
  function delete (line 56) | void delete(list_t list) {
  function obj_t (line 68) | obj_t get(list) {
  function list_t (line 73) | list_t next(list) {
  function main (line 78) | int main()

FILE: C10-Elementary-Data-Structures/exercise_code/deque.cpp
  class Deque (line 8) | class Deque {
    method Deque (line 19) | Deque(int size) : size_(0), head_(0), tail_(size-1), capacity_(size), ...
    method push_front (line 21) | void push_front(T v) {
    method push_back (line 27) | void push_back(T v) {
    method pop_front (line 33) | void pop_front() {
    method pop_back (line 39) | void pop_back() {
    method T (line 45) | T front() const {
    method T (line 50) | T back() const {
    method size (line 55) | int size() const { return size_; }
    method empty (line 57) | int empty() const { return size_ == 0; }
  function main (line 63) | int main() {

FILE: C10-Elementary-Data-Structures/exercise_code/deque.py
  class Deque (line 4) | class Deque:
    method __init__ (line 6) | def __init__(self, size):
    method addFirst (line 13) | def addFirst(self, item):
    method addLast (line 18) | def addLast(self, item):
    method removeFirst (line 23) | def removeFirst(self):
    method removeLast (line 29) | def removeLast(self):
    method seeAll (line 35) | def seeAll(self):

FILE: C10-Elementary-Data-Structures/exercise_code/dict.cpp
  type node_t (line 12) | struct node_t {
    type node_t (line 14) | struct node_t
  type list_t (line 17) | struct list_t{
    type node_t (line 18) | struct node_t
  function init_list (line 21) | void init_list(list_t *list) {
  function destroy_list (line 26) | void destroy_list(list_t *list) {
  function insert (line 37) | void insert(list_t *list, int key) {
  function node_t (line 44) | node_t *search(list_t *list, int key) {
    type node_t (line 14) | struct node_t
  function del (line 59) | void del(list_t *list, int key) {
  function main (line 73) | int main()

FILE: C10-Elementary-Data-Structures/exercise_code/traversal.cpp
  type tree_t (line 11) | struct tree_t {
    type tree_t (line 12) | struct tree_t
    type tree_t (line 13) | struct tree_t
    type tree_t (line 14) | struct tree_t
    method tree_t (line 16) | tree_t() {left = 0; right = 0; parent = 0;}
  function print_tree (line 19) | void print_tree(tree_t *tree) {
  function main (line 41) | int main() {

FILE: C12-Binary-Search-Trees/BSTree.h
  type BSTNode (line 28) | typedef BSTNode* bp;
  function insert (line 36) | void insert(const type& a_data) {insertAux(m_root,a_data);}
  function inorder (line 38) | void inorder(ostream& out) const {inorderAux(out, m_root);}
  function graph (line 39) | void graph(ostream& out) const {graphAux(out, 0, m_root);}

FILE: C12-Binary-Search-Trees/main.cpp
  function main (line 15) | int main()

FILE: C13-Red-Black-Trees/rbtree.c
  type key_t (line 13) | typedef int key_t;
  type data_t (line 14) | typedef int data_t;
  type color_t (line 16) | typedef enum color_t {
  type rb_node_t (line 20) | typedef struct rb_node_t {
  function main (line 37) | int main()
  function rb_node_t (line 87) | rb_node_t* rb_new_node(key_t key, data_t data) {
  function rb_node_t (line 111) | rb_node_t* rb_rotate_left(rb_node_t* node, rb_node_t* root)
  function rb_node_t (line 150) | rb_node_t* rb_rotate_right(rb_node_t* node, rb_node_t* root)
  function rb_node_t (line 186) | rb_node_t* rb_search_auxiliary(key_t key, rb_node_t* root, rb_node_t** s...
  function rb_node_t (line 218) | rb_node_t* rb_search(key_t key, rb_node_t* root)
  function rb_node_t (line 227) | rb_node_t* rb_insert(key_t key, data_t data, rb_node_t* root)
  function rb_node_t (line 269) | rb_node_t* rb_insert_rebalance(rb_node_t *node, rb_node_t *root)
  function rb_node_t (line 344) | rb_node_t* rb_erase(key_t key, rb_node_t *root)
  function rb_node_t (line 471) | rb_node_t* rb_erase_rebalance(rb_node_t *node, rb_node_t *parent, rb_nod...

FILE: C13-Red-Black-Trees/rbtree.cpp
  class RedBlackTreeNode (line 17) | class RedBlackTreeNode
    method RedBlackTreeNode (line 20) | RedBlackTreeNode():key(T()),parent(NULL),left(NULL),right(NULL),color(...
  class RedBlackTree (line 29) | class RedBlackTree
  function T (line 227) | T RedBlackTree<T>::get_key(RedBlackTreeNode<T>* pnode) const
  function main (line 514) | int main()

FILE: C14-Augmenting-Data-Structures/exercise_code/m-Josephus.cpp
  type node (line 11) | struct node
    method node (line 15) | node(int i){no = i;}
  function main (line 18) | int main()

FILE: C15-Dynamic-Programming/Assembly-line-sche.c
  function Fastway (line 4) | int Fastway(int *a1,int *a2,int *t1,int *t2,int *e,int *x,int n,int *l1,...
  function PRINT_STATIONS (line 48) | void PRINT_STATIONS(int *l1,int *l2,int way,int n)
  function reverse_PRINT_STATIONS (line 64) | void reverse_PRINT_STATIONS(int *l1,int *l2,int way,int n)
  function main (line 76) | int main()

FILE: C15-Dynamic-Programming/Matrix-chain-multiplication.c
  function MATRIX_CHAIN_ORDER (line 9) | void MATRIX_CHAIN_ORDER(int *p,int n,int **m,int **s)
  function PRINT_OPTIMAL_PARRNS (line 43) | void PRINT_OPTIMAL_PARRNS(int **s,int i,int j,int row)
  function main (line 55) | int main()

FILE: C15-Dynamic-Programming/lincrs.cpp
  function find (line 4) | int find(int *a, int len, int n)
  function main (line 17) | int main()

FILE: C15-Dynamic-Programming/optimalBST.cpp
  function optimalBST (line 16) | void optimalBST(double *p,double *q,int n)
  function printRoot (line 48) | void printRoot()
  function printOptimalBST (line 64) | void printOptimalBST(int i,int j,int r)
  function main (line 98) | int main()

FILE: C15-Dynamic-Programming/rodcutting.cpp
  function CutRod (line 11) | int CutRod(const std::vector<int> &p, const int &n)
  function MemoizedCutRodAux (line 29) | int MemoizedCutRodAux(const std::vector<int> &p, const int &n, std::vect...
  function MemoizedCutRod (line 53) | int MemoizedCutRod(const std::vector<int> &p, const int &n)
  function BottomUpCutRod (line 60) | int BottomUpCutRod(const std::vector<int> &p, const int &n)
  function main (line 75) | int main()

FILE: C16-Greedy-Algorithms/huffman/BinaryStdIn.h
  function class (line 17) | class BinaryStdIn

FILE: C16-Greedy-Algorithms/huffman/BinaryStdOut.h
  function class (line 17) | class BinaryStdOut

FILE: C16-Greedy-Algorithms/huffman/HUFFMAN.cpp
  function Htree (line 123) | Htree * HUFFMAN::readTrie() {
  function string (line 132) | string HUFFMAN::decode(string filename) {

FILE: C16-Greedy-Algorithms/huffman/HUFFMAN.h
  function Htree (line 22) | struct Htree {
  function isLeaf (line 33) | static inline bool isLeaf(Htree *node) {
  function class (line 38) | class myComparision
  function class (line 46) | class HUFFMAN {

FILE: C16-Greedy-Algorithms/huffman/binary_test/main.cpp
  function main (line 13) | int main()

FILE: C16-Greedy-Algorithms/huffman/binarystdin_test/main.cpp
  function main (line 12) | int main()

FILE: C16-Greedy-Algorithms/huffman/binarystdout_test/main.cpp
  function main (line 12) | int main()

FILE: C16-Greedy-Algorithms/huffman/huffman_test/huffman_test_client.cpp
  function main (line 12) | int main()

FILE: C18-B-Trees/btree.cpp
  class Btree (line 21) | class Btree
    type Node (line 26) | struct Node
      method Node (line 33) | Node(bool b=true, int _n=0) : isLeaf(b), n(_n){}
    method Btree (line 42) | Btree()
    method viewStatistics (line 48) | void viewStatistics()
    method B_tree_insert (line 55) | void B_tree_insert(T k)
    method PrintTree (line 75) | void PrintTree(int kind = 1) const //打印树的关键字
    method T (line 109) | T get_minimum() const
    method T (line 114) | T get_maximum() const
    method search (line 119) | bool search(T k)
    method remove (line 136) | bool remove(const T &key)    //从B中删除结点key
    method clear (line 152) | void clear()                      //清空B树
    method deleteNode (line 159) | void deleteNode(Node *pNode)
    method Node (line 170) | Node *allocate_node()
      method Node (line 33) | Node(bool b=true, int _n=0) : isLeaf(b), n(_n){}
    method disk_write (line 182) | void disk_write(Node *x) const
    method disk_read (line 189) | void disk_read(Node *x) const
    method B_tree_create (line 196) | void B_tree_create()
    method B_tree_split_child (line 202) | void B_tree_split_child(Node *x, int i, Node *y)
    method B_tree_insert_nonfull (line 229) | void B_tree_insert_nonfull(Node *x, T k)
    method T (line 260) | T B_TREE_FIND_MIN(Node *x) const
    method T (line 280) | T B_TREE_FIND_MAX(Node *x) const
    method T (line 296) | T B_tree_find_predecessor(Node *x, int i)
    method buildPath (line 334) | void buildPath(Node *x, T k, stack<Node*>& mystack)
    method Node (line 348) | Node* B_tree_search(Node *x, T k, int *index)
      method Node (line 33) | Node(bool b=true, int _n=0) : isLeaf(b), n(_n){}
    method recursive_clear (line 367) | void recursive_clear(Node *pNode)
    method recursive_remove (line 381) | void recursive_remove(Node *pNode, const T &key)
    method mergeChild (line 486) | void mergeChild(Node *pParent, int index)
    method T (line 516) | T getPredecessor(Node *pNode)//找到前驱关键字
    method T (line 525) | T getSuccessor(Node *pNode)//找到后继关键字
  function main (line 537) | int main() {

FILE: C18-B-Trees/btree.py
  function main (line 7) | def main():
  class BTree (line 181) | class BTree:
    method __init__ (line 182) | def __init__(self, t = 2, allocate = None, free = None, read = None, w...
    method find (line 203) | def find(self, key):
    method create (line 230) | def create(self):
    method load (line 240) | def load(self, root):
    method insert (line 261) | def insert(self, key, value):
    method remove (line 298) | def remove(self, key):
    method __find (line 331) | def __find(self, node, key):
    method __split_root (line 339) | def __split_root(self):
    method __insert_in_nonfull (line 348) | def __insert_in_nonfull(self, node, key, value):
    method __split_child (line 369) | def __split_child(self, node, child):
    method __remove (line 380) | def __remove(self, node, key):
    method __remove_predecessor (line 425) | def __remove_predecessor(self, node):
    method __remove_successor (line 442) | def __remove_successor(self, node):
    method __extend_child (line 459) | def __extend_child(self, node, child, left = None, right = None):
    method __write_page (line 511) | def __write_page(self, node):
    method __read_page (line 517) | def __read_page(self, node, root = False):
    method __free_page (line 526) | def __free_page(self, node):
    method __flush_page (line 530) | def __flush_page(self, node):
    class Node (line 536) | class Node:
      method __init__ (line 537) | def __init__(self, t, page, leaf = True):
      method leaf (line 549) | def leaf(self):
      method empty (line 552) | def empty(self):
      method full (line 555) | def full(self):
      method hasminimum (line 558) | def hasminimum(self):
      method page (line 561) | def page(self):
      method entries (line 564) | def entries(self):
      method children (line 567) | def children(self):
      method major (line 570) | def major(self):
      method minor (line 574) | def minor(self):
      method leftest (line 578) | def leftest(self):
      method second_leftest (line 587) | def second_leftest(self):
      method rightest (line 597) | def rightest(self):
      method second_rightest (line 606) | def second_rightest(self):
      method find (line 616) | def find(self, key):
      method siblings (line 630) | def siblings(self, key):
      method insert (line 641) | def insert(self, key, value, right = None):
      method remove_leftest (line 658) | def remove_leftest(self):
      method remove_rightest (line 672) | def remove_rightest(self):
      method remove (line 686) | def remove(self, key, remove_right = True):
      method replace (line 700) | def replace(self, key, newkey, newvalue):
      method split (line 710) | def split(self, parent, newnode):
      method join (line 725) | def join(self, newkey, newvalue, right = None):
      method read (line 735) | def read(self, leaf, root, keyvalues, children):
      method free (line 756) | def free(self):
      method __position (line 762) | def __position(self, key):
  class BTreeNotInitializedError (line 766) | class BTreeNotInitializedError(Exception):
    method __init__ (line 767) | def __init__(self):
  class BTreeInvalidNodeError (line 771) | class BTreeInvalidNodeError(Exception):
    method __init__ (line 772) | def __init__(self, warning, page):
    method page (line 776) | def page(self):

FILE: C19-Binomial-Heaps/BinomialHeap.h
  function mRoot (line 90) | mRoot(NULL)

FILE: C19-Binomial-Heaps/Main.cpp
  function testInsert (line 23) | void testInsert()
  function testUnion (line 41) | void testUnion()
  function testDelete (line 78) | void testDelete()
  function testDecrease (line 102) | void testDecrease()
  function testIncrease (line 126) | void testIncrease()
  function main (line 149) | int main()

FILE: C21-Data-Structures-for-Disjoint-Sets/uf.cpp
  class UF (line 6) | class UF {
    method validate (line 14) | bool validate(int p) {
    method UF (line 20) | UF(int N) : parent(N), rank(N, 0), N(N), count(N) {
    method find (line 26) | int find(int p) {
    method getCount (line 35) | int getCount() const {
    method connected (line 39) | bool connected(int p, int q) {
    method Union (line 43) | void Union(int p, int q) {
  function main (line 61) | int main() {

FILE: C22-Elementary-Graph-Algorithms/elementary_graph_algo.py
  class Graph (line 6) | class Graph:
    method __init__ (line 7) | def __init__(self, adj_list):
    method bfs (line 16) | def bfs(self, start):
    method bfs_path (line 27) | def bfs_path(self, start, end):
    method connected_component (line 42) | def connected_component(self):
    method dfs (line 57) | def dfs(self, start, adj_list, visited=None):
    method strongly_connected_component (line 70) | def strongly_connected_component(self):
  class GraphTest (line 125) | class GraphTest(unittest.TestCase):
    method setUp (line 126) | def setUp(self):
    method test_bfs (line 135) | def test_bfs(self):
    method test_bfs_path (line 139) | def test_bfs_path(self):
    method test_connected_component (line 143) | def test_connected_component(self):
    method test_dfs (line 154) | def test_dfs(self):
    method test_strongly_connected_components (line 163) | def test_strongly_connected_components(self):

FILE: C22-Elementary-Graph-Algorithms/exercise_code/EulerTour.cpp
  function input (line 23) | static void input() {
  function euler (line 37) | static void euler(int x) {
  function main (line 48) | int main() {

FILE: C25-All-Pairs-Shortest-Paths/Floyd_Warshall.cpp
  function floydWarshell (line 21) | void floydWarshell (int graph[][V])
  function printSolution (line 47) | void printSolution()
  function printPre (line 64) | void printPre()
  function findPath (line 80) | void findPath(int start, int end) {
  function main (line 94) | int main()

FILE: C26-Flow-networks/maxflow/FlowEdge.cpp
  class FlowEdge (line 15) | class FlowEdge {
    method FlowEdge (line 22) | FlowEdge() {
    method FlowEdge (line 29) | FlowEdge(int v, int w, double capacity) {
    method FlowEdge (line 36) | FlowEdge(int v, int w, double capacity, double flow) {
    method FlowEdge (line 43) | FlowEdge(const FlowEdge &e) {
    method from (line 50) | int from() {
    method to (line 54) | int to() {
    method getCapacity (line 58) | double getCapacity() {
    method getFlow (line 62) | double getFlow() {
    method other (line 66) | int other(int vertex) {
    method residualCapacityTo (line 71) | double residualCapacityTo(int vertex) {
    method addResidualFlowTo (line 76) | void addResidualFlowTo(int vertex, double delta) {
    method ostream (line 81) | ostream& operator << (ostream& out, FlowEdge& fe)

FILE: C26-Flow-networks/maxflow/FlowNetwork.cpp
  class FlowNetwork (line 20) | class FlowNetwork {
    method FlowNetwork (line 28) | FlowNetwork(int V) {
    method FlowNetwork (line 37) | FlowNetwork(ifstream& in) {
    method getV (line 54) | int getV() {
    method getE (line 58) | int getE() {
    method addEdge (line 62) | void addEdge(FlowEdge e) {
    method getadj (line 70) | list<FlowEdge> getadj(int v) {
    method addResidualFlowTo (line 74) | void addResidualFlowTo(FlowEdge e, int v, double bottle) {
    method edges (line 83) | list<FlowEdge> edges() {
    method ostream (line 93) | ostream& operator << (ostream& out, FlowNetwork& fn)

FILE: C26-Flow-networks/maxflow/FordFulkerson.cpp
  class FordFulkerson (line 26) | class FordFulkerson {
    method excess (line 34) | double excess(FlowNetwork G, int v) {
    method check (line 44) | bool check(FlowNetwork G, int s, int t) {
    method isFeasible (line 80) | bool isFeasible(FlowNetwork G, int s, int t) {
    method hasAugmentingPath (line 117) | bool hasAugmentingPath(FlowNetwork G, int s, int t) {
    method FordFulkerson (line 153) | FordFulkerson(FlowNetwork G, int s, int t) {
    method getvalue (line 175) | double getvalue()  {
    method inCut (line 179) | bool inCut(int v)  {
  function main (line 185) | int main() {

FILE: C26-Flow-networks/maxflow/testFlowEdge.cpp
  function main (line 12) | int main() {

FILE: C26-Flow-networks/maxflow/testFlowNetwork.cpp
  function main (line 14) | int main() {

FILE: C31-Number-Theoretic-Algorithms/euclid.py
  function gcd (line 4) | def gcd(a, b):

FILE: C31-Number-Theoretic-Algorithms/exercise_code/binary2decimal.py
  function b2d (line 4) | def b2d(binary, base):

FILE: C31-Number-Theoretic-Algorithms/exercise_code/lcm.py
  function gcd (line 4) | def gcd(a, b):
  function lcm (line 12) | def lcm(items):

FILE: C31-Number-Theoretic-Algorithms/extended_euclid.py
  function ee (line 4) | def ee(a, b):

FILE: C32-String-Matching/BF.c
  function BF_match (line 8) | int BF_match(char *text,char *pattern)
  function main (line 32) | int main()

FILE: C32-String-Matching/BM.c
  function max (line 5) | int max(int a,int b)
  function BM_match (line 15) | int BM_match(char* pSrc, int nSrcSize, char* pSubSrc, int nSubSrcSize)
  function main (line 86) | int main()

FILE: C32-String-Matching/FA.c
  function min (line 8) | int min(int a,int b)
  function suffix (line 16) | int suffix(char *pattern,int k,int q,char ch)
  function compute_transition_function (line 30) | void compute_transition_function(char *pattern,int *array,int numchars)
  function FA_match (line 53) | int FA_match(char *text,int *array,int numchars,int receive)
  function main (line 68) | int main()

FILE: C32-String-Matching/KMP.c
  function KMP_match (line 27) | int KMP_match(char *text,char *pattern)
  function main (line 49) | int main()

FILE: C32-String-Matching/RK.c
  function factorial (line 6) | int factorial(int n)
  function RK_match (line 21) | int RK_match(char *text,char *pattern,int d,int q)

FILE: C32-String-Matching/exercise_code/str_spin.c
  function f (line 8) | int f(char *s1,char *s2)
  function main (line 27) | int main()

FILE: C33-Computational-Geometry/Graham_Scan.py
  class Point (line 9) | class Point:
    method __init__ (line 11) | def __init__(self, x, y):
    method __eq__ (line 18) | def __eq__(self, p):
    method __sub__ (line 21) | def __sub__(self, p):
    method __mul__ (line 27) | def __mul__(self, p):
    method __dict__ (line 33) | def __dict__(self):
    method dist (line 37) | def dist(cls, P, Q=None):
    method dot (line 46) | def dot(cls, P, Q):
    method direction (line 53) | def direction(cls, P, Q, R):
    method angle (line 61) | def angle(cls, P, Q, R=None):
    method polar_sort (line 81) | def polar_sort(cls, p0, *P):
  class ConvexHull (line 93) | class ConvexHull:
    method __init__ (line 94) | def __init__(self, *P):
    method graham_scan (line 97) | def graham_scan(self):
  class ConvexHullTest (line 138) | class ConvexHullTest(unittest.TestCase):
    method test_graham_scan (line 139) | def test_graham_scan(self):
  class PointTest (line 146) | class PointTest(unittest.TestCase):
    method test_polar_sort (line 147) | def test_polar_sort(self):
    method test_angle (line 154) | def test_angle(self):

FILE: C33-Computational-Geometry/exercise_code/area.cpp
  type Point (line 5) | struct Point{
  function area (line 10) | float area(Point a, Point b, Point c){
  function calculateAreaOfHull (line 15) | float calculateAreaOfHull(Point* hull,int N){
  function main (line 22) | int main(){

FILE: C33-Computational-Geometry/exercise_code/colinear.cpp
  class Point (line 15) | class Point
    method Point (line 20) | Point(float _x, float _y):x(_x),y(_y){}
    method Point (line 21) | Point():x(0.0),y(0.0){}
    method Point (line 23) | Point operator +(const Point &that) const
    method Point (line 28) | Point operator -(const Point &that) const
    method Point (line 33) | Point& operator =(const Point &that)
    method reverse (line 42) | void reverse()
    method ostream (line 48) | ostream& operator << (ostream& os, const Point &p)
  function myfunc (line 55) | bool myfunc(const Point &p1, const Point &p2)
  function crossProduct (line 65) | float crossProduct(const Point &p1, const Point &p2)
  function main (line 70) | int main() {

FILE: C33-Computational-Geometry/exercise_code/convex_polygon.cpp
  class Point (line 13) | class Point
    method Point (line 18) | Point(float _x, float _y):x(_x),y(_y){}
    method Point (line 20) | Point operator +(const Point &that) const
    method Point (line 25) | Point operator -(const Point &that) const
    method Point (line 30) | Point& operator =(const Point &that)
  function crossProduct (line 40) | float crossProduct(const Point &p1, const Point &p2)
  function direction (line 45) | float direction(const Point &pi, const Point &pj, const Point &pk)
  function isConvexPolygon (line 50) | bool isConvexPolygon(Point points[], int n)
  function main (line 72) | int main() {

FILE: C33-Computational-Geometry/exercise_code/pointpolygon.cpp
  class Point (line 13) | class Point
    method Point (line 22) | Point(float _x, float _y):x(_x),y(_y){}
    method Point (line 24) | Point operator +(const Point &that) const
    method Point (line 29) | Point operator -(const Point &that) const
    method Point (line 34) | Point& operator =(const Point &that)
    method inTheLine (line 43) | bool inTheLine(Point p1, Point p2)
  class Point (line 17) | class Point
    method Point (line 22) | Point(float _x, float _y):x(_x),y(_y){}
    method Point (line 24) | Point operator +(const Point &that) const
    method Point (line 29) | Point operator -(const Point &that) const
    method Point (line 34) | Point& operator =(const Point &that)
    method inTheLine (line 43) | bool inTheLine(Point p1, Point p2)
  function crossProduct (line 51) | float crossProduct(const Point &p1, const Point &p2)
  function direction (line 56) | float direction(const Point &pi, const Point &pj, const Point &pk)
  function onSegmant (line 61) | bool onSegmant(const Point &pi, const Point &pj, const Point &pk)
  function segmentsInterect (line 68) | bool segmentsInterect(const Point &p1, const Point &p2, const Point &p3,...
  function point_polygon_pos (line 92) | int point_polygon_pos(Point p0, Point polygon[], int n)
  function main (line 116) | int main() {

FILE: C33-Computational-Geometry/exercise_code/polarCMP.cpp
  class Point (line 13) | class Point
    method Point (line 18) | Point(float _x, float _y):x(_x),y(_y){}
    method Point (line 20) | Point operator +(const Point &that) const
    method Point (line 25) | Point operator -(const Point &that) const
    method Point (line 30) | Point& operator =(const Point &that)
    method ostream (line 39) | ostream& operator << (ostream& os, const Point &p)
  function myfunc (line 46) | bool myfunc(const Point &p1, const Point &p2)
  function main (line 56) | int main() {

FILE: C33-Computational-Geometry/exercise_code/ray_intersection.cpp
  class Point (line 13) | class Point
    method Point (line 18) | Point(float _x, float _y):x(_x),y(_y){}
    method Point (line 20) | Point operator +(const Point &that) const
    method Point (line 25) | Point operator -(const Point &that) const
    method Point (line 30) | Point& operator =(const Point &that)
  function crossProduct (line 40) | float crossProduct(const Point &p1, const Point &p2)
  function direction (line 45) | float direction(const Point &pi, const Point &pj, const Point &pk)
  function onSegmant (line 50) | bool onSegmant(const Point &pi, const Point &pj, const Point &pk)
  function segmentsInterect (line 57) | bool segmentsInterect(const Point &p1, const Point &p2, const Point &p3,...
  function main (line 76) | int main() {

FILE: C33-Computational-Geometry/twoline.cpp
  class Point (line 13) | class Point
    method Point (line 18) | Point(float _x, float _y):x(_x),y(_y){}
    method Point (line 20) | Point operator +(const Point &that) const
    method Point (line 25) | Point operator -(const Point &that) const
    method Point (line 30) | Point& operator =(const Point &that)
  function crossProduct (line 40) | float crossProduct(const Point &p1, const Point &p2)
  function direction (line 45) | float direction(const Point &pi, const Point &pj, const Point &pk)
  function onSegmant (line 50) | bool onSegmant(const Point &pi, const Point &pj, const Point &pk)
  function segmentsInterect (line 57) | bool segmentsInterect(const Point &p1, const Point &p2, const Point &p3,...
  function main (line 76) | int main() {

FILE: other/Karatsuba/Karatsuba.cpp
  function makeEqualLength (line 6) | int makeEqualLength(string &str1, string &str2)
  function string (line 24) | string add(string &first, string &second)
  function string (line 45) | string multiplyiSingleBit(string &a, string &b)
  function string (line 48) | string sub(string num1, string num2) {
  function string (line 73) | string multiply(string &X, string &Y)
  function main (line 113) | int main(int argc, char **argv)

FILE: other/Karatsuba/main.cpp
  function string (line 6) | string multiply(string &num1, string &num2) {
  function main (line 27) | int main(int argc, char **argv) {

FILE: other/segmentTree.cpp
  type SegmentTreeNode (line 6) | struct SegmentTreeNode {
    method SegmentTreeNode (line 9) | SegmentTreeNode(int start, int end, int sum) {
  class NumArray (line 17) | class NumArray {
    method SegmentTreeNode (line 21) | SegmentTreeNode* build(int start, int end, const vector<int>& A) {
    method modify (line 36) | void modify(SegmentTreeNode *root, int i, int val) {
    method query (line 46) | int query(SegmentTreeNode *root, int i, int j) {
    method NumArray (line 60) | NumArray(vector<int> &nums) {
    method update (line 64) | void update(int i, int val) {
    method sumRange (line 68) | int sumRange(int i, int j) {
  function main (line 73) | int main() {

FILE: other/stringSpilit.cpp
  function split (line 1) | vector<string> split(const string &s, char delim) {

FILE: other/trie.cpp
  type TrieNode (line 1) | struct TrieNode {
    method TrieNode (line 5) | TrieNode(): word(false) {
  class Trie (line 10) | class Trie {
    method Trie (line 13) | Trie() {
    method insert (line 18) | void insert(const string& s) {
    method search (line 31) | bool search(const string& key) const {
    method startsWith (line 45) | bool startsWith(const string& prefix) const {