# Additional Learning

### Additional Learning

```
I added them to help you become a well-rounded software engineer, and to be aware of certain
technologies and algorithms, so you'll have a bigger toolbox.
```

* **Linear Programming (videos)**
  * [Linear Programming](https://www.youtube.com/watch?v=M4K6HYLHREQ)
  * [Finding minimum cost](https://www.youtube.com/watch?v=2ACJ9ewUC6U)
  * [Finding maximum value](https://www.youtube.com/watch?v=8AA_81xI3ik)
  * [Solve Linear Equations with Python - Simplex Algorithm](https://www.youtube.com/watch?v=44pAWI7v5Zk)
* **Geometry, Convex hull (videos)**
  * [Graph Alg. IV: Intro to geometric algorithms - Lecture 9](https://youtu.be/XIAQRlNkJAw?list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm\&t=3164)
  * [Geometric Algorithms: Graham & Jarvis - Lecture 10](https://www.youtube.com/watch?v=J5aJEcOr6Eo\&index=10\&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm)
  * [Divide & Conquer: Convex Hull, Median Finding](https://www.youtube.com/watch?v=EzeYI7p9MjU\&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp\&index=2)
* **Discrete math**
  * [Computer Science 70, 001 - Spring 2015 - Discrete Mathematics and Probability Theory](http://www.infocobuild.com/education/audio-video-courses/computer-science/cs70-spring2015-berkeley.html)
  * [Discrete Mathematics by Shai Simonson (19 videos)](https://www.youtube.com/playlist?list=PLWX710qNZo_sNlSWRMVIh6kfTjolNaZ8t)
  * [Discrete Mathematics By IIT Ropar NPTEL](https://nptel.ac.in/courses/106/106/106106183/)
* Machine Learning
  * Why ML?
    * [How Google Is Remaking Itself As A Machine Learning First Company](https://backchannel.com/how-google-is-remaking-itself-as-a-machine-learning-first-company-ada63defcb70)
    * [Large-Scale Deep Learning for Intelligent Computer Systems (video)](https://www.youtube.com/watch?v=QSaZGT4-6EY)
    * [Deep Learning and Understandability versus Software Engineering and Verification by Peter Norvig](https://www.youtube.com/watch?v=X769cyzBNVw)
  * [Google's Cloud Machine learning tools (video)](https://www.youtube.com/watch?v=Ja2hxBAwG_0)
  * [Google Developers' Machine Learning Recipes (Scikit Learn & Tensorflow) (video)](https://www.youtube.com/playlist?list=PLOU2XLYxmsIIuiBfYad6rFYQU_jL2ryal)
  * [Tensorflow (video)](https://www.youtube.com/watch?v=oZikw5k_2FM)
  * [Tensorflow Tutorials](https://www.tensorflow.org/versions/r0.11/tutorials/index.html)
  * [Practical Guide to implementing Neural Networks in Python (using Theano)](http://www.analyticsvidhya.com/blog/2016/04/neural-networks-python-theano/)
  * Courses:
    * [Great starter course: Machine Learning](https://www.coursera.org/learn/machine-learning) - [videos only](https://www.youtube.com/playlist?list=PLZ9qNFMHZ-A4rycgrgOYma6zxF4BZGGPW) - see videos 12-18 for a review of linear algebra(Who doesen't Know Andrew NG : P , Still Addding it)
    * [Neural Networks for Machine Learning](https://www.coursera.org/learn/neural-networks-deep-learning)
    * [Google's Deep Learning Nanodegree](https://www.udacity.com/course/deep-learning--ud730)
    * [Google/Kaggle Machine Learning Engineer Nanodegree](https://www.udacity.com/course/machine-learning-engineer-nanodegree-by-google--nd009)
    * [Self-Driving Car Engineer Nanodegree](https://www.udacity.com/drive)
    * [Metis Online Course ($99 for 2 months)](http://www.thisismetis.com/explore-data-science)
  * Resources:
    * Books:
      * [Python Machine Learning](https://www.amazon.com/Python-Machine-Learning-Sebastian-Raschka/dp/1783555130/)
      * [Data Science from Scratch: First Principles with Python](https://drive.google.com/file/d/1PrRtXT4lY3G01nMATNljPP1aI-mwG35i/view?usp=sharing)
      * [Introduction to Machine Learning with Python](http://noracook.io/Books/Python/introductiontomachinelearningwithpython.pdf)
    * Data School: <http://www.dataschool.io/>
* **Compilers**
  * [How a Compiler Works in \~1 minute (video)](https://www.youtube.com/watch?v=IhC7sdYe-Jg)
  * [Harvard CS50 - Compilers (video)](https://www.youtube.com/watch?v=CSZLNYF4Klo)
  * [C++ (video)](https://www.youtube.com/watch?v=twodd1KFfGk)
  * [Understanding Compiler Optimization (C++) (video)](https://www.youtube.com/watch?v=FnGCDLhaxKU)
* **Emacs and vi(m)**
  * Familiarize yourself with a unix-based code editor
  * vi(m):
    * [Editing With vim 01 - Installation, Setup, and The Modes (video)](https://www.youtube.com/watch?v=5givLEMcINQ\&index=1\&list=PL13bz4SHGmRxlZVmWQ9DvXo1fEg4UdGkr)
    * [VIM Adventures](http://vim-adventures.com/)
    * set of 4 videos:
      * [The vi/vim editor - Lesson 1](https://www.youtube.com/watch?v=SI8TeVMX8pk)
      * [The vi/vim editor - Lesson 2](https://www.youtube.com/watch?v=F3OO7ZIOaJE)
      * [The vi/vim editor - Lesson 3](https://www.youtube.com/watch?v=ZYEccA_nMaI)
      * [The vi/vim editor - Lesson 4](https://www.youtube.com/watch?v=1lYD5gwgZIA)
    * [Using Vi Instead of Emacs](http://www.cs.yale.edu/homes/aspnes/classes/223/notes.html#Using_Vi_instead_of_Emacs)
  * emacs:
    * [Basics Emacs Tutorial (video)](https://www.youtube.com/watch?v=hbmV1bnQ-i0)
    * set of 3 (videos):
      * [Emacs Tutorial (Beginners) -Part 1- File commands, cut/copy/paste, cursor commands](https://www.youtube.com/watch?v=ujODL7MD04Q)
      * [Emacs Tutorial (Beginners) -Part 2- Buffer management, search, M-x grep and rgrep modes](https://www.youtube.com/watch?v=XWpsRupJ4II)
      * [Emacs Tutorial (Beginners) -Part 3- Expressions, Statements, \~/.emacs file and packages](https://www.youtube.com/watch?v=paSgzPso-yc)
    * [Evil Mode: Or, How I Learned to Stop Worrying and Love Emacs (video)](https://www.youtube.com/watch?v=JWD1Fpdd4Pc)
    * [Writing C Programs With Emacs](http://www.cs.yale.edu/homes/aspnes/classes/223/notes.html#Writing_C_programs_with_Emacs)
    * [(maybe) Org Mode In Depth: Managing Structure (video)](https://www.youtube.com/watch?v=nsGYet02bEk)
* **Unix command line tools**
  * I filled in the list below from good tools.
  * bash
  * cat
  * grep
  * sed
  * awk
  * curl or wget
  * sort
  * tr
  * uniq
  * [strace](https://en.wikipedia.org/wiki/Strace)
  * [tcpdump](https://danielmiessler.com/study/tcpdump/)
* **Information theory (videos)**
  * [Khan Academy](https://www.khanacademy.org/computing/computer-science/informationtheory)
  * More about Markov processes:
    * [Core Markov Text Generation](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/waxgx/core-markov-text-generation)
    * [Core Implementing Markov Text Generation](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/gZhiC/core-implementing-markov-text-generation)
    * [Project = Markov Text Generation Walk Through](https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/EUjrq/project-markov-text-generation-walk-through)
  * See more in MIT 6.050J Information and Entropy series below
* **Parity & Hamming Code (videos)**
  * [Intro](https://www.youtube.com/watch?v=q-3BctoUpHE)
  * [Parity](https://www.youtube.com/watch?v=DdMcAUlxh1M)
  * Hamming Code:
    * [Error detection](https://www.youtube.com/watch?v=1A_NcXxdoCc)
    * [Error correction](https://www.youtube.com/watch?v=JAMLuxdHH8o)
  * [Error Checking](https://www.youtube.com/watch?v=wbH2VxzmoZk)
* **Entropy**
  * Also see videos below
  * Make sure to watch information theory videos first
  * [Information Theory, Claude Shannon, Entropy, Redundancy, Data Compression & Bits (video)](https://youtu.be/JnJq3Py0dyM?t=176)
* **Cryptography**
  * Also see videos below
  * Make sure to watch information theory videos first
  * [Khan Academy Series](https://www.khanacademy.org/computing/computer-science/cryptography)
  * [Cryptography: Hash Functions](https://www.youtube.com/watch?v=KqqOXndnvic\&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp\&index=30)
  * [Cryptography: Encryption](https://www.youtube.com/watch?v=9TNI2wHmaeI\&index=31\&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
* **Compression**
  * Make sure to watch information theory videos first
  * Computerphile (videos):
    * [Compression](https://www.youtube.com/watch?v=Lto-ajuqW3w)
    * [Entropy in Compression](https://www.youtube.com/watch?v=M5c_RFKVkko)
    * [Upside Down Trees (Huffman Trees)](https://www.youtube.com/watch?v=umTbivyJoiI)
    * [EXTRA BITS/TRITS - Huffman Trees](https://www.youtube.com/watch?v=DV8efuB3h2g)
    * [Elegant Compression in Text (The LZ 77 Method)](https://www.youtube.com/watch?v=goOa3DGezUA)
    * [Text Compression Meets Probabilities](https://www.youtube.com/watch?v=cCDCfoHTsaU)
  * [Compressor Head videos](https://www.youtube.com/playlist?list=PLOU2XLYxmsIJGErt5rrCqaSGTMyyqNt2H)
  * [(optional) Google Developers Live: GZIP is not enough!](https://www.youtube.com/watch?v=whGwm0Lky2s)
* **Computer Security**
  * [MIT (23 videos)](https://www.youtube.com/playlist?list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
    * [Introduction, Threat Models](https://www.youtube.com/watch?v=GqmQg-cszw4\&index=1\&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
    * [Control Hijacking Attacks](https://www.youtube.com/watch?v=6bwzNg5qQ0o\&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh\&index=2)
    * [Buffer Overflow Exploits and Defenses](https://www.youtube.com/watch?v=drQyrzRoRiA\&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh\&index=3)
    * [Privilege Separation](https://www.youtube.com/watch?v=6SIJmoE9L9g\&index=4\&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
    * [Capabilities](https://www.youtube.com/watch?v=8VqTSY-11F4\&index=5\&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
    * [Sandboxing Native Code](https://www.youtube.com/watch?v=VEV74hwASeU\&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh\&index=6)
    * [Web Security Model](https://www.youtube.com/watch?v=chkFBigodIw\&index=7\&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
    * [Securing Web Applications](https://www.youtube.com/watch?v=EBQIGy1ROLY\&index=8\&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
    * [Symbolic Execution](https://www.youtube.com/watch?v=yRVZPvHYHzw\&index=9\&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
    * [Network Security](https://www.youtube.com/watch?v=SIEVvk3NVuk\&index=11\&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
    * [Network Protocols](https://www.youtube.com/watch?v=QOtA76ga_fY\&index=12\&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
    * [Side-Channel Attacks](https://www.youtube.com/watch?v=PuVMkSEcPiI\&index=15\&list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
* **Garbage collection**
  * [GC in Python (video)](https://www.youtube.com/watch?v=iHVs_HkjdmI)
  * [Deep Dive Java: Garbage Collection is Good!](https://www.infoq.com/presentations/garbage-collection-benefits)
  * [Deep Dive Python: Garbage Collection in CPython (video)](https://www.youtube.com/watch?v=P-8Z0-MhdQs\&list=PLdzf4Clw0VbOEWOS_sLhT_9zaiQDrS5AR\&index=3)
* **Parallel Programming**
  * [Coursera (Scala)](https://www.coursera.org/learn/parprog1/home/week/1)
  * [Efficient Python for High Performance Parallel Computing (video)](https://www.youtube.com/watch?v=uY85GkaYzBk)
* **Messaging, Serialization, and Queueing Systems**
  * [Thrift](https://thrift.apache.org/)
    * [Tutorial](http://thrift-tutorial.readthedocs.io/en/latest/intro.html)
  * [Protocol Buffers](https://developers.google.com/protocol-buffers/)
    * [Tutorials](https://developers.google.com/protocol-buffers/docs/tutorials)
  * [gRPC](http://www.grpc.io/)
    * [gRPC 101 for Java Developers (video)](https://www.youtube.com/watch?v=5tmPvSe7xXQ\&list=PLcTqM9n_dieN0k1nSeN36Z_ppKnvMJoly\&index=1)
  * [Redis](http://redis.io/)
    * [Tutorial](http://try.redis.io/)
  * [Amazon SQS (queue)](https://aws.amazon.com/sqs/)
  * [Amazon SNS (pub-sub)](https://aws.amazon.com/sns/)
  * [RabbitMQ](https://www.rabbitmq.com/)
    * [Get Started](https://www.rabbitmq.com/getstarted.html)
  * [Celery](http://www.celeryproject.org/)
    * [First Steps With Celery](http://docs.celeryproject.org/en/latest/getting-started/first-steps-with-celery.html)
  * [ZeroMQ](http://zeromq.org/)
    * [Intro - Read The Manual](http://zeromq.org/intro:read-the-manual)
  * [ActiveMQ](http://activemq.apache.org/)
  * [Kafka](http://kafka.apache.org/documentation.html#introduction)
  * [MessagePack](http://msgpack.org/index.html)
  * [Avro](https://avro.apache.org/)
* **A\***
  * [A Search Algorithm](https://en.wikipedia.org/wiki/A*_search_algorithm)
  * [A\* Pathfinding Tutorial (video)](https://www.youtube.com/watch?v=KNXfSOx4eEE)
  * [A\* Pathfinding (E01: algorithm explanation) (video)](https://www.youtube.com/watch?v=-L-WgKMFuhE)
* **Fast Fourier Transform**
  * [An Interactive Guide To The Fourier Transform](https://betterexplained.com/articles/an-interactive-guide-to-the-fourier-transform/)
  * [What is a Fourier transform? What is it used for?](http://www.askamathematician.com/2012/09/q-what-is-a-fourier-transform-what-is-it-used-for/)
  * [What is the Fourier Transform? (video)](https://www.youtube.com/watch?v=Xxut2PN-V8Q)
  * [Divide & Conquer: FFT (video)](https://www.youtube.com/watch?v=iTMn0Kt18tg\&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp\&index=4)
  * [Understanding The FFT](http://jakevdp.github.io/blog/2013/08/28/understanding-the-fft/)
* **Bloom Filter**
  * Given a Bloom filter with m bits and k hashing functions, both insertion and membership testing are O(k)
  * [Bloom Filters (video)](https://www.youtube.com/watch?v=-SuTGoFYjZs)
  * [Bloom Filters | Mining of Massive Datasets | Stanford University (video)](https://www.youtube.com/watch?v=qBTdukbzc78)
  * [Tutorial](http://billmill.org/bloomfilter-tutorial/)
  * [How To Write A Bloom Filter App](http://blog.michaelschmatz.com/2016/04/11/how-to-write-a-bloom-filter-cpp/)
* **HyperLogLog**
  * [How To Count A Billion Distinct Objects Using Only 1.5KB Of Memory](http://highscalability.com/blog/2012/4/5/big-data-counting-how-to-count-a-billion-distinct-objects-us.html)
* **Locality-Sensitive Hashing**
  * Used to determine the similarity of documents
  * The opposite of MD5 or SHA which are used to determine if 2 documents/strings are exactly the same
  * [Simhashing (hopefully) made simple](http://ferd.ca/simhashing-hopefully-made-simple.html)
* **van Emde Boas Trees**
  * [Divide & Conquer: van Emde Boas Trees (video)](https://www.youtube.com/watch?v=hmReJCupbNU\&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp\&index=6)
  * [MIT Lecture Notes](https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-046j-design-and-analysis-of-algorithms-spring-2012/lecture-notes/MIT6_046JS12_lec15.pdf)
* **Augmented Data Structures**
  * [CS 61B Lecture 39: Augmenting Data Structures](https://archive.org/details/ucberkeley_webcast_zksIj9O8_jc)
* **Balanced search trees**
  * Know at least one type of balanced binary tree (and know how it's implemented):
  * "Among balanced search trees, AVL and 2/3 trees are now passé, and red-black trees seem to be more popular. A particularly interesting self-organizing data structure is the splay tree, which uses rotations to move any accessed key to the root." - Skiena
  * Of these, I chose to implement a splay tree. From what I've read, you won't implement a balanced search tree in your interview. But I wanted exposure to coding one up and let's face it, splay trees are the bee's knees. I did read a lot of red-black tree code
    * Splay tree: insert, search, delete functions If you end up implementing red/black tree try just these:
    * Search and insertion functions, skipping delete
  * I want to learn more about B-Tree since it's used so widely with very large data sets
  * [Self-balancing binary search tree](https://en.wikipedia.org/wiki/Self-balancing_binary_search_tree)
  * **AVL trees**
    * In practice: From what I can tell, these aren't used much in practice, but I could see where they would be: The AVL tree is another structure supporting O(log n) search, insertion, and removal. It is more rigidly balanced than red–black trees, leading to slower insertion and removal but faster retrieval. This makes it attractive for data structures that may be built once and loaded without reconstruction, such as language dictionaries (or program dictionaries, such as the opcodes of an assembler or interpreter)
    * [MIT AVL Trees / AVL Sort (video)](https://www.youtube.com/watch?v=FNeL18KsWPc\&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb\&index=6)
    * [AVL Trees (video)](https://www.coursera.org/learn/data-structures/lecture/Qq5E0/avl-trees)
    * [AVL Tree Implementation (video)](https://www.coursera.org/learn/data-structures/lecture/PKEBC/avl-tree-implementation)
    * [Split And Merge](https://www.coursera.org/learn/data-structures/lecture/22BgE/split-and-merge)
  * **Splay trees**
    * In practice: Splay trees are typically used in the implementation of caches, memory allocators, routers, garbage collectors, data compression, ropes (replacement of string used for long text strings), in Windows NT (in the virtual memory, networking and file system code) etc
    * [CS 61B: Splay Trees (video)](https://archive.org/details/ucberkeley_webcast_G5QIXywcJlY)
    * MIT Lecture: Splay Trees:
      * Gets very mathy, but watch the last 10 minutes for sure.
      * [Video](https://www.youtube.com/watch?v=QnPl_Y6EqMo)
  * **Red/black trees**
    * These are a translation of a 2-3 tree (see below).
    * In practice: Red–black trees offer worst-case guarantees for insertion time, deletion time, and search time. Not only does this make them valuable in time-sensitive applications such as real-time applications, but it makes them valuable building blocks in other data structures which provide worst-case guarantees; for example, many data structures used in computational geometry can be based on red–black trees, and the Completely Fair Scheduler used in current Linux kernels uses red–black trees. In the version 8 of Java, the Collection HashMap has been modified such that instead of using a LinkedList to store identical elements with poor hashcodes, a Red-Black tree is used
    * [Aduni - Algorithms - Lecture 4 (link jumps to starting point) (video)](https://youtu.be/1W3x0f_RmUo?list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm\&t=3871)
    * [Aduni - Algorithms - Lecture 5 (video)](https://www.youtube.com/watch?v=hm2GHwyKF1o\&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm\&index=5)
    * [Red-Black Tree](https://en.wikipedia.org/wiki/Red%E2%80%93black_tree)
    * [An Introduction To Binary Search And Red Black Tree](https://www.topcoder.com/community/competitive-programming/tutorials/an-introduction-to-binary-search-and-red-black-trees/)
  * **2-3 search trees**
    * In practice: 2-3 trees have faster inserts at the expense of slower searches (since height is more compared to AVL trees).
    * You would use 2-3 tree very rarely because its implementation involves different types of nodes. Instead, people use Red Black trees.
    * [23-Tree Intuition and Definition (video)](https://www.youtube.com/watch?v=C3SsdUqasD4\&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6\&index=2)
    * [Binary View of 23-Tree](https://www.youtube.com/watch?v=iYvBtGKsqSg\&index=3\&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6)
    * [2-3 Trees (student recitation) (video)](https://www.youtube.com/watch?v=TOb1tuEZ2X4\&index=5\&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
  * **2-3-4 Trees (aka 2-4 trees)**
    * In practice: For every 2-4 tree, there are corresponding red–black trees with data elements in the same order. The insertion and deletion operations on 2-4 trees are also equivalent to color-flipping and rotations in red–black trees. This makes 2-4 trees an important tool for understanding the logic behind red–black trees, and this is why many introductory algorithm texts introduce 2-4 trees just before red–black trees, even though **2-4 trees are not often used in practice**.
    * [CS 61B Lecture 26: Balanced Search Trees (video)](https://archive.org/details/ucberkeley_webcast_zqrqYXkth6Q)
    * [Bottom Up 234-Trees (video)](https://www.youtube.com/watch?v=DQdMYevEyE4\&index=4\&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6)
    * [Top Down 234-Trees (video)](https://www.youtube.com/watch?v=2679VQ26Fp4\&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6\&index=5)
  * **N-ary (K-ary, M-ary) trees**
    * note: the N or K is the branching factor (max branches)
    * binary trees are a 2-ary tree, with branching factor = 2
    * 2-3 trees are 3-ary
    * [K-Ary Tree](https://en.wikipedia.org/wiki/K-ary_tree)
  * **B-Trees**
    * Fun fact: it's a mystery, but the B could stand for Boeing, Balanced, or Bayer (co-inventor).
    * In Practice: B-Trees are widely used in databases. Most modern filesystems use B-trees (or Variants). In addition to its use in databases, the B-tree is also used in filesystems to allow quick random access to an arbitrary block in a particular file. The basic problem is turning the file block i address into a disk block (or perhaps to a cylinder-head-sector) address
    * [B-Tree](https://en.wikipedia.org/wiki/B-tree)
    * [B-Tree Datastructure](http://btechsmartclass.com/data_structures/b-trees.html)
    * [Introduction to B-Trees (video)](https://www.youtube.com/watch?v=I22wEC1tTGo\&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6\&index=6)
    * [B-Tree Definition and Insertion (video)](https://www.youtube.com/watch?v=s3bCdZGrgpA\&index=7\&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6)
    * [B-Tree Deletion (video)](https://www.youtube.com/watch?v=svfnVhJOfMc\&index=8\&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6)
    * [MIT 6.851 - Memory Hierarchy Models (video)](https://www.youtube.com/watch?v=V3omVLzI0WE\&index=7\&list=PLUl4u3cNGP61hsJNdULdudlRL493b-XZf) - covers cache-oblivious B-Trees, very interesting data structures - the first 37 minutes are very technical, may be skipped (B is block size, cache line size)
* **k-D Trees**
  * Great for finding number of points in a rectangle or higher dimension object
  * A good fit for k-nearest neighbors
  * [Kd Trees (video)](https://www.youtube.com/watch?v=W94M9D_yXKk)
  * [kNN K-d tree algorithm (video)](https://www.youtube.com/watch?v=Y4ZgLlDfKDg)
* **Skip lists**
  * "These are somewhat of a cult data structure" - Skiena
  * [Randomization: Skip Lists (video)](https://www.youtube.com/watch?v=2g9OSRKJuzM\&index=10\&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
  * [For animations and a little more detail](https://en.wikipedia.org/wiki/Skip_list)
* **Network Flows**
  * [Ford-Fulkerson in 5 minutes — Step by step example (video)](https://www.youtube.com/watch?v=Tl90tNtKvxs)
  * [Ford-Fulkerson Algorithm (video)](https://www.youtube.com/watch?v=v1VgJmkEJW0)
  * [Network Flows (video)](https://www.youtube.com/watch?v=2vhN4Ice5jI)
* **Disjoint Sets & Union Find**
  * [UCB 61B - Disjoint Sets; Sorting & selection (video)](https://archive.org/details/ucberkeley_webcast_MAEGXTwmUsI)
  * [Sedgewick Algorithms - Union-Find (6 videos)](https://www.coursera.org/learn/algorithms-part1/home/week/1)
* **Math for Fast Processing**
  * [Integer Arithmetic, Karatsuba Multiplication (video)](https://www.youtube.com/watch?v=eCaXlAaN2uE\&index=11\&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
  * [The Chinese Remainder Theorem (used in cryptography) (video)](https://www.youtube.com/watch?v=ru7mWZJlRQg)
* **Treap**
  * Combination of a binary search tree and a heap
  * [Treap](https://en.wikipedia.org/wiki/Treap)
  * [Data Structures: Treaps explained (video)](https://www.youtube.com/watch?v=6podLUYinH8)
  * [Applications in set operations](https://www.cs.cmu.edu/~scandal/papers/treaps-spaa98.pdf)

> For Add-ons and Recommendations feel free to reach me at  : <vivekanandayadla@gmail.com>\
> My Other Social Media Accounts:\
> \
> &#x20;      [Facebook](https://www.facebook.com/vivekanandayadla/)               [LinkedIn ](https://www.linkedin.com/in/vivekananda-yadla/)                [Instagram](https://www.instagram.com/_dumb_physicist_/)                   [ Twitter](https://twitter.com/NoobCoder14)                  [WhatsApp](https://api.whatsapp.com/send?phone=+919390827947)
