1) Stack: Data Structure with a storage policy that abides by
LIFO (last in first out)
a) Important Methods for a stack:
i) Boolean empty(): returns true if the stack is
empty, otherwise false
ii) E peek(): returns the object at the top of the
stack without removing it.
iii) E pop(): Returns the object at the top of the
stack and removes it.
iv) E push(E obj): Pushes an item onto the top of
the stack and return the item pushed.
b) Stacks can be implemented by using a vector, or a
list
i) Vector: is a poor choice for stack
implementation, since Vector is a built in java
API, and is extended to the stack class, therefore
implementing all vector methods
ii) The easiest implementation is a List (specifically
and ArrayList)
(1) An underlying array requires reallocation of
space when the array becomes full
(2) An underlying linked data structure requires
allocating storage for links
(3) All insertions and deletions occur at one
end, and are constant time to perform the
action (O(1)).
2) Queue: Like a stack but a queue abides by FIFO (first in
first out)
a) The queue behaves like a line: the next person is line
is to person who has waited the longest and is next
to be served, and new elements are places at the
end of the line
b) There are three ways to implement a queue
i) Singly Linked List: Linked list implementation
requires more storage due to the extra space
required for the links
ii) Doubly Linked List: requires 1.5x the storage of a
singly linked list
iii) Circular Array:
(1) when the circular array is filled to capacity,
it requires half the storage of a single linked
list
(2) But a recently reallocated circular array is
half empty and require the same storage as
a single linked list
iv) Regardless of implementation: all operations
are O(1)
(1) Although reallocating an array is O(n), it is
amortized over n items, so the cost per item
is O(1)
3) Deque: allows insertions and removals from both ends of
the queue
a) Can be implemented as an ArrayDeque or a Linked
list
i) ArrayDeque uses a resizable circular array, and
does not support indexed operations.
(1) ArrayDeque is the recommended
implementation
4) Trees: can represent hierarchical organizations of
information (i.e. family tree, class hierarchy, etc.). Note,
although there are numerous types of tree data
structures, the scope of the notes focuses mainly on
binary trees
a) Trees are a recursive data structure because they
utilize many recursive methods
b) One of the reasons binary trees are useful, is
because they are more efficient to search than an
array or linked data structure O(log n) vs. O(n)
c) Tree Terminology:
i) Root: the node at the top of the tree
ii) Branches: the links from a node to its successors
iii) Children: the successors of a node
iv) Parent: the predecessor of a node
v) Siblings: nodes that have the same parent
vi) Leaf: a node that has no children (also known as
external nodes)
(1) Nonleaf nodes are known as internal nodes
vii) Height of the tree: the number of nodes in the
longest path from the root node to the leaf
node
d) A set of nodes T is a binary tree if either of the
following is true
i) T is empty
ii) Its root node has two subtree, TL = left subtree,
TR = right subtree, such that TL and TR are binary
trees
(1) T is greater than all values in TL and is less
than all values in TR
e) Huffman Tree: represents Huffman codes for
characters that might appear in a text file.
i) Huffman code uses different numbers of bits to
encode letters; more common characters use
fewer bits
ii) Programs that need to compress files may use
Huffman codes
f) A binary tree never has to be sorted because its
elements are inserted and removed in a manner that
maintains the binary trees order
g) When searching a BST (binary search tree), each
probe has the potential to eliminate half the
elements in the tree; yielding that searching can be
O(log n)
i) Worst case is O(n)
h) Recursive Algorithm for searching a binary tree:
1
 i) if the tree is empty
(1) return null (target is not found)
ii) else if the target matches the root node's data
(1) return the data stored at the root node
iii) else if the target is less than the root node's
data
(1) return the result of searching the left
subtree of the root
iv) else
(1) return the result of searching the right
subtree of the root
i) Full binary tree: a binary tree where all nodes have
either 2 children or 0 children
j) Perfect binary tree: is a full binary tree of height n
with exactly 2n -1 nodes
Figure 2: Example of a perfect binary tree: n=3 and
2n-1 = 7
k) Complete binary tree: is a perfect binary tree
through level n-1 with some extra lead nodes at level
n (the tree height), all toward the left
Figure 3: example of a complete binary tree
i) Tree Traversal: determining the nodes of a tree
and their relationship by walking through the
tree in a prescribed order and visiting the nodes
as they are encountered
(1) Three types of traversals:
(a) Inorder: traverse TL, visit root node,
traverse TL
(b) Presorder: visit root node, Traverse TL,
traverse TR
(c) Postorder: Traverse TL, traverse TR, visit
root node
Figure 4: Sudocode to acquire eachs traversal
5) Heaps: a complete binary tree
a) has the following properties:
i) the value in the root is the smallest item in the
tree
ii) every nonempty subtree is a heap
b) inserting into a heap
i) insert the new item in the next position at the
bottom of the heap
ii) while new item is not at the root and new item
is smaller than its parent
(1) swap the new item with its parent, moving
the new item up the heap
c) Removing an item from a heap
i) Remove the item in the root node by replacing it
with the last item in the heap (LIH)
ii) While item LIH has children and item LIH is
larger than either of its children
(1) Swap item LIH with its smaller child, moving
LIH down the heap
d) Because a heap is a complete binary tree, it is
efficiently implemented using an array, rather than a
linked data structure
e) Finding the value in the heap from the array in which
it is stored.
i) For a node at position p
(1) L child position = 2p+1
(2) R child position = 2p+2
ii) For a child to find its parent (position c)
(1) Position of parent = (c-1)/2
f) The insertion and removal are O(log n)
6) Priority Queue: a data structure in which only the
highest-priority item is accessible
a) In a priority queue, the smallest item always is
removed first
i) A priority queue implements the characteristics
of a heap, and therefore yields that the insertion
and removal of a priority queue is O(log n)