COP3530 Final Review

What is the height of a tree?

# of nodes in longest path from root to leaf if (tree has only root) height = 1 else height = 1 + max(height(children))

binary heaps

- Complete binary trees - Each node < children in MIN heap (where we prioritize smallest element) - Each node > children in MAX heap (where we prioritize largest element) - Only root can be removed via ExtractMin(), ExtractMax()

how to make a max heap

1. Iterate through the tree with an In Order traversal and store the values 2. Pass through the tree with a Post Order traversal 3. For each node you pass in the Post Order, replace it with the stored node of the In Order traversal at the same index

how to make a min heap

1. Iterate through the tree with an In Order traversal and store the values 2. Pass through the tree with a Pre Order traversal 3. For each node you pass in the Pre Order, replace it with the stored node of the In Order traversal at the same index

What are the different tree types?

1. N-ary Tree 2. Full Binary Tree 3. Complete Binary Tree 4. Perfect Binary Tree 5. Binary Search Tree

Two characteristics for all heaps

1. it is a complete binary tree, so heaps are nearly always implemented using the array representation for complete binary trees 2. values in a heap are partially ordered, meaning there is a relationship between the value stored at any node and the values of its children

How can we design a priority queue data structure to be really fast?

1. use an unsorted array 2. use a sorted array 3. use a sorted list 4. use a binary heap!

With an array representation of a binary heap, how do you get the right child position of a node at position p?

2p + 2

With an array representation of a binary heap, how do you get the left child position of a node at position p?

2p+1

What is the time complexity of deleting an element from a min heap?

O(logn)

What is the time complexity of inserting an element into a heap?

O(logn)

T or F: A full tree is not necessarily complete

True

True or false: A perfect tree is ALWAYS complete and full

True

What is heap sort?

Turn array into heap

How do we go through lists?

Using iterators for( list<int>::iterator it = myList.begin(); it != myList.end(); it++) {cout << *it << endl;} // accesses element iterator is pointing to

Do binary heaps need to be complete trees?

Yes

Is there a necessary relationship between the value of a node and that of its sibling in either the min heap or the max heap?

Yes

What is a data structure?

a specialized format for organizing and storing data ex. Lists, stacks, and queues

n-ary tree

a tree that limits each node to no more than n children i.e. (Binary trees can have AT MOST 2 children)

Min heap

a tree that maintains the simple property that a node's key is less than or equal to the node's children's keys. Because the root has a value less than or equal to its children, which in turn have values less than or equal to their children, the root stores the minimum of all values in the tree.

a SINGLE stack can be used to handle which of the following? A. undo feature B. Balancing parenthesis C. Task scheduling D. Evaluating expressions

a, b, d

PushBack(data)

adds a new node to the end of the linked list

What does it mean for a tree to be complete?

all levels are completely filled except possibly the last level. The last level has all nodes as far left as possible

Binary Search Tree

all values in any node's left subtree are less than node, all values in any node's right subtree are greater than node.

What is heap sort and its time complexity?

an algorithm that sorts an array O(N * log(N)) 1. Insert n items (from array) into a heap == building a heap in place, and then inserting into it 2. Remove n items from heap and place in array building a heap in place = O(N)

WHICH OF THE FOLLOWING STATEMENTS ABOUT LINKED LISTS AND ARRAYS ARE TRUE? A) both data structures store elements sequentially (contiguously) in memory B) both data structures use iterators C) Both are linear data types D) Linked lists are more efficient if you need random access

b, c

Perfect and Complete trees with n nodes have height

ceil(log2/logn)

what is "heapify up" and when is it used?

done after inserting to correct the heap ■ Corrects the path between the inserted node and root

Performance of array-based queue

enqueue(element): O(1) - dequeue(): O(1) - size(): O(1) - isEmpty(): O(1)

time complexity for inserting element and finding the element with the highest priority and removing it for sorted array

extractMin-O(1) //element with highest priority is at position 0. Simply remove it insert - O(n) // find position where element should go, //insert it

time complexity for inserting element and finding the element with the highest priority and remove it for unsorted array

extractMin-O(n); //find the element with the highest priority and remove it insert - O(1); //just add it to the end

With an array representation of a binary heap, how do you get the position of the parent of a node at position p?

floor((p-1)/2)

How can you turn an array into a heap?

for (i = size/2; i>0;i--) heapifyDown(i)

why are insert and pop operations both log(n)?

heapify()

How is the depth/level of a tree measured?

if (node n is the root) level(n) = 0 else level(n) = level(parent) + 1

How do we solve the "rightward shift" problem?

implement a queue using a "circular array"

time complexity for inserting element and finding the element with the highest priority and removing it for a sorted list

insert - O(n) //find position where element should go and insert it extractMin-O(1) //element with highest priority is at position 0. Simply remove it

what is "heapify down" and when is it used?

is done after deleting to correct the heap ■ Moves last element to root ■ Corrects a path from the new root to a leaf

formulas to find child for a 1-indexed array

left child: 2i right child: 2i + 1 parent: i/2* (floor the result)

formulas to find child for a 0-indexed array

left child: 2i + 1 right child: 2i + 2 parent: (i-1)/2* (floor the result)

inorder traversal

left, root, right *prints nodes in SORTED order

With an array representation, in what order are binary heaps stored?

level order

height for a binary heap

log(n)

Does a heap implement partial or total order?

partial. BST implements total

TopBack()

peeks at the node at the end of the linked list (if no tail, we need to traverse the whole list)

Characteristics of a stack implementation

push(element) - pop() - top() - size() - isEmpty()

Performance of array-based stack and list-based stack

push(element): O(1) - pop(): O(1) - top(): O(1) - size(): O(1) - isEmpty(): O(1)

Operations of a list ADT

read/write element, add/remove element, find element, count, traverse list

Pre-Order Traversal

root, left, right *prints the root first

Characteristics of a singly linked list (no tail)

stored non-contiguously in memory, does not allow random access

Compiler error

syntax error

PopBack()

takes off the node at the end of the linked list

inorder predecessor

the left subtree's rightmost child

inorder successor

the right subtree's leftmost child

what is heapify used for?

to turn any tree/array into a heap

Subtree

tree whose root is a child of that node

true or false: only the root can be removed in a Pop operation

true

What is the worst case for tree traversal?

O(n) (where n is the # of nodes that there are)

Worst case for BST insertion

O(n). The "splindly" tree requires O(n) for find, insert after, and delete since it has to iterate through all of the elements The "bushy" tree is a complete tree w/ height of ceil(log2/logn). Finding, deleting, and inserting after is O(log n)

Drawbacks of a singly linked list (no tail)

TopBack, PushBack, PopBack and AddBefore are expensive

What is the time complexity of heap sort?

O(nlogn)

For doubly linked list with tail, these operations become O(1)

PopBack() and AddBefore(Node, data)

For singly linked list with a tail, these operations become O(1)

PushBack() and TopBack()

Performance of a singly linked list (w/ tail)

PushFront: O(1) PopFront: O(1), TopFront: O(1) Find: O(n) *PushBack: O(1) -PopBack: O(n) *TopBack: O(1) Erase: O(n) Empty: O(1) -AddBefore(Node, Key): O(n) AddAfter(Node, Key): O(1)

Performance of a singly linked list (no tail)

PushFront: O(1) PopFront: O(1), TopFront: O(1) Find: O(n) PushBack: O(n) PopBack: O(n) TopBack: O(n) Erase: O(n) Empty: O(1) AddBefore(Node, Key): O(n) AddAfter(Node, Key): O(1)

What is the algorithm for deleting a node in a heap?

Remove the root node, take the last element of the heap and make it the root node. While the new root has children and is greater than both it's children, swap with the smaller child.

Characteristics of singly linked list (w/ tail)

Stores similar elements, elements are linked in memory but stored non-contiguously, doesn't allow for random access

Benefits of an array-based list

Constant access time, arr[i] = arr + (i*sizeOf(type))

What is the algorithm for making a max heap from a BST?

Create array of elements with inorder traversal of BST. Pass through the BST with post order traversal, replacing every element with the node from the inorder traversal at the same index.

What is the algorithm for making a min heap from a BST?

Create array of elements with inorder traversal of BST. Pass through the BST with pre order traversal, replacing every element with the node from the inorder traversal at the same index.

2 types of BST traversals

Depth-First Search (DFS) and Breadth-First Search (BFS)

T or F: A complete tree is always full

FALSE

true or false: doubly linked lists allow random access in the container in constant time

FALSE

true or false: linked lists are more efficient than arrays if you have to access elements with O(1) time.

FALSE

T or False: A complete and full tree is always perfect

False

True or false: Doubly linked lists do not require more memory

False

Characteristics of a list implementation for an array

Finite size, stores similar elements, contiguous, allows for random access

Which of the following container(s) are list ADT implementations in C++?

Forward list, array, vector

For singly linked list, these operations are O(1)

Front(), isEmpty(), and AddAfter

Perfect Binary Tree

Full binary tree of height H with exactly (2^h) -1 nodes. The height of a tree w/ n nodes is ceil(logn/log2). a type of binary tree in which every internal node has exactly two child nodes and all the leaf nodes are at the same level

For a max-heap, is each node greater than or less than its children?

Greater

Complete Binary Tree

In a complete binary tree every level, except possibly the last, is completely filled, and all nodes in the last level are as far left as possible.

time complexity for inserting element and finding the element with the highest priority and removing it for a binary heap

Insert element - O(log(n)) ExtractMin() - O(log(n))

What are the steps for heap sort no building in place?

Insert n items into heap, remove n items from heap and place into array

What is the algorithm for inserting a node into a min heap?

Insert new item at the bottom of the heap. While new item is not the root and new item is smaller than its parent, swap new item with parent.

For a min-heap, is each node less than or greater than its children?

Less

Is stack[i] allowed?

NO. ABSOLUTELY NOT. There is NO RANDOM ACCESS (we access through top index)

Can you remove a non root node in a binary heap?

No

Is every binary tree a BST

No. All BST's are Binary Tree however only some Binary Tree's may be also BST.

What are leaves?

Node with no children (external nodes)

What are trees?

Non-linear ordered data structure that is rooted, directed, and has no cycles

Max heap

A binary tree that maintains the simple property that a node's key is greater than or equal to the node's children's keys. Because the root has a value greater than or equal to its children, which in turn have values greater than or equal to their children, the root stores the maximum of all values in the tree.

What's a priority queue?

A queue in which all elements inserted have some priority - Elements with highest priority are removed first

What is an ADT?

Abstract Data Type, a class of objects whose logical behavior is defined by data and operations

Performance for an array-based list

Adding an element to the beginning: O(N) Removing an element from the beginning: O(N) Removing an element from the end: O(1) Adding an element to the end: O(1) Adding in the middle: O(N) Removing in the middle: O(N)

Benefits of a singly linked list (no tail)

Adding/Removing in front is easier, O(1)

Full Binary Tree

All nodes have either 0 children, OR 2 children (the leaf nodes)

Runtime error

An error that does not occur until the program has started to execute but that prevents the program from continuing.

What is big o of deleting an element from a doubly linked list w/ tail in the worst case in terms of big o notation?

O(n)

What is the time complexity for a building a heap inplace?

O(n)