Added clang, gdb, valgrind.

plan.txt

@@ -61,6 +61,11 @@ Some videos are available only by enrolling in a Coursera or EdX class. It is fr
 
 * - C
     * - K&R C book (ANSI C)
+    * - Clang: https://www.youtube.com/watch?v=U3zCxnj2w8M
+    * - GDB:
+        - https://www.youtube.com/watch?v=USPvePv1uzE
+        - https://www.youtube.com/watch?v=y5JmQItfFck
+      - Valgrind: https://www.youtube.com/watch?v=fvTsFjDuag8
 - C++
     * - basics
     * - pointers
@@ -136,16 +141,23 @@ Then test it out on a computer to make sure it's not buggy from syntax.
 Arrays
     * - Description:
         - Arrays: https://www.coursera.org/learn/data-structures/lecture/OsBSF/arrays
+        - Arrays: https://www.lynda.com/Developer-Programming-Foundations-tutorials/Basic-arrays/149042/177104-4.html
+        - Multi-dim: https://www.lynda.com/Developer-Programming-Foundations-tutorials/Multidimensional-arrays/149042/177105-4.html
         - Dynamic Arrays: https://www.coursera.org/learn/data-structures/lecture/EwbnV/dynamic-arrays
-        - Resizing arrays: https://class.coursera.org/algs4partI-010/lecture/19
-    - Implement:
+        - Jagged: https://www.lynda.com/Developer-Programming-Foundations-tutorials/Jagged-arrays/149042/177106-4.html
+        - Resizing arrays:
+            - https://class.coursera.org/algs4partI-010/lecture/19
+            - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Resizable-arrays/149042/177108-4.html
+    - Implement a vector (mutable array with automatic resizing):
         * - Practice coding using arrays and pointers, and pointer math to jump to an index instead of using indexing.
-        * - new raw data array with allocated memory (can allocate int array under the hood, just not use its features)
+        * - new raw data array with allocated memory
+            - can allocate int array under the hood, just not use its features
+            - start with 16, or if starting number is greater, use power of 2 - 16, 32, 64, 128
         * - size() - number of items
         * - capacity() - number of items it can hold
         * - is_empty()
-        - at(index) - returns item at given index
-        - append(item) - or push(item)
+        - at(index) - returns item at given index, blows up if index out of bounds
+        - append(item) - or push(item) - check size of element 2^
         - insert(index, item)
         - prepend(item) - can use insert above at index 0
         - delete(index)
@@ -159,8 +171,8 @@ Arrays
         - O(n) to insert/remove elsewhere
     - Space
         - contiguous in memory, so proximity helps performance
-        - space needed = size of object * number of items to store
-linked lists
+        - space needed = (array capacity, which is >= n) * size of item
+Linked lists
     - singly-linked
         * - Description: https://www.coursera.org/learn/data-structures/lecture/kHhgK/singly-linked-lists
         * - Lynda.com:
@@ -188,14 +200,13 @@ linked lists
     - doubly-linked list
         - Description: https://www.coursera.org/learn/data-structures/lecture/jpGKD/doubly-linked-lists
     - reverse a singly-linked list
-stacks
+Stacks
     - see: https://class.coursera.org/algs4partI-010/lecture
     - https://www.coursera.org/learn/data-structures/lecture/UdKzQ/stacks
-queues
+Queues
     - see: https://class.coursera.org/algs4partI-010/lecture
     - https://www.coursera.org/learn/data-structures/lecture/EShpq/queues
-Vectors
-heaps
+Heaps
     - https://www.coursera.org/learn/data-structures/lecture/GRV2q/binary-trees
     - min heap
     - max heap
@@ -207,14 +218,14 @@ Priority Queue
 Disjoint Sets:
     - https://www.coursera.org/learn/data-structures/lecture/JssSY/overview
     - https://www.coursera.org/learn/data-structures/lecture/Mxu0w/trees
-hashtables
+Hash tables
     - https://www.youtube.com/watch?v=C4Kc8xzcA68
     - https://class.coursera.org/algs4partI-010/lecture/52
     - https://www.coursera.org/learn/data-structures/home/week/3
     - see: https://class.coursera.org/algs4partI-010/lecture
     - https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/m7UuP/core-hash-tables
     - test: implement with only arrays
-tries
+Tries
     - https://www.coursera.org/learn/data-structures-optimizing-performance/lecture/08Xyf/core-introduction-to-tries
 Circular buffer/FIFO:
     - https://en.wikipedia.org/wiki/Circular_buffer
@@ -231,14 +242,18 @@ Bit operations
         https://www.youtube.com/watch?v=JAMLuxdHH8o
     Error Checking:
         https://www.youtube.com/watch?v=wbH2VxzmoZk
-binary search
+Binary search
 Sorting
-    - no bubble sort - it's terrible
-    - at least one n*log(n) sorting algorithm, preferably two (say, quicksort and merge sort)
-    - Which algorithms can be used on lists? Which on arrays? Which on both? Is Quicksort stable?
-    - algos:
+    - stability in sorting algorithms:
+        - http://stackoverflow.com/questions/1517793/stability-in-sorting-algorithms
+        - http://www.geeksforgeeks.org/stability-in-sorting-algorithms/
+    - Which algorithms can be used on linked lists? Which on arrays? Which on both? Is Quicksort stable?
+    - Implement & know best case/worst case, average complexity of each:
         - mergesort
         - quicksort
+        - insertion sort
+        - selection sort
+    - no bubble sort - it's terrible at O(n^2)
 Caches
     - LRU cache
 Trees
@@ -293,6 +308,8 @@ open-ended problems
     - manipulate strings
     - manipulate patterns
 design patterns:
+    - description:
+        - https://www.lynda.com/Developer-Programming-Foundations-tutorials/Foundations-Programming-Design-Patterns/135365-2.html
     - strategy
     - singleton
     - adapter