DATA STRUCTURES
A container that stores data in a specific and organized layout.
(YouTube)
Arrays & Strings
Linear data structures that are mostly concerned with the ordering and accessing of data.
(YouTube)
ARRAYS
A collection of the items where items can be accessed by an index. Can be one or two dimensional.
Ex: If you need to store an image (1000x1000px) as a bitmap, you can use a 2D array that's 1000x1000px. (YouTube)
SETS
Similar to arrays, but this collection of items can only contain unique values.
Ex: Storing the names of everyone on a basketball team; you can only include team members, and you can't repeat any names. (YouTube)
LINKED LISTS
Lists that store data inside of nodes (basic units for storing data) that point to each other, but the order is strict.
Ex: A playlist of songs is a Doubly Linked List, since each song points to both the previous and next songs. (YouTube)
HASH TABLES
A list-like structure that uses a hash function to generate keys for each value. It's like scrambling a bunch of donuts to make new donuts, each one having a specific key. If you can use a Hash Table, use it!
Ex: When you need to store and dynamically add social network feeds, and you don't know the size, you can use a Hash Table to uniquely identify each new feed. (YouTube)
Stacks & Queues
Linear data structures that are defined by how items are added and removed.
(YouTube)
STACKS
Follows the ordering principle of “Last In First Out” (LIFO). It's like eating a stack of donuts; when you want a donut, you take the donut on top of the stack.
Ex: A history of your recently visited websites is a Stack. (YouTube)
QUEUES
Follows the ordering principle of “First In First Out” (FIFO). It's like waiting in line to buy donuts; if you're at the front of the line, you get to leave first.
Ex: Programming a printer Queue can make sure that jobs are printed in the order of their arrival. (YouTube)
Trees & Graphs
Non-linear data structures that have nodes (basic units for storing data) and edges (lines that connect nodes to each other). Tree edges are more rigid than graphs.
(YouTube)
TREES
A tree-like structure in which nodes can store lists of child nodes.
Ex: Navigating all your Mac files through Finder. Also, a (very) large tree can store all the possible moves in a chess game. (YouTube)
BINARY TREES
Trees that store values in left and right pointers. A Binary Search Tree is where every node fits a specific ordering.
Ex: A family tree in which every member has two children. (YouTube)
BREADTH FIRST SEARCH (BFS)
A queue-like search that traverses a tree from left to right, then top to bottom, like reading each level of all the nodes.
Ex: Good for finding the shortest path between two nodes. (YouTube)
DEPTH FIRST SEARCH (DFS)
A stack-like search that traverses a tree from top to bottom, visiting all a node's child nodes before moving from left to right to its siblings.
Ex: Good for looking for paths and values far away from our source. (YouTube)
TRIES
Trees that aren't limited to only left and right pointers, but they usually only store alphabetical data as collections of strings.
Ex: Many search dictionaries are built upon Tries. (YouTube)
GRAPHS
Any collection of nodes and edges, in which any node can have multiple edges to other nodes.
Ex: A group of people on Facebook make up a Graph; some people follow each other while others only follow one-way. (YouTube)