# ECE 250: DSA

## Heaps

A heap is a binary tree **stored in an array** in which all levels but the lowest are filled. It is guaranteed that the parent of index $i$ is greater than or equal to the element at index $i$.

- the parent of index $i$ is stored at $i/2$
- the left child of index $i$ is stored at $2i$
- the right child of index $i$ is stored at $2i+1$


<img src="https://upload.wikimedia.org/wikipedia/commons/c/c4/Max-Heap-new.svg" width=600>(Source: Wikimedia Commons)</img>

The **heapify** command takes a node and makes it and its children a valid heap.

```rust
fn heapify(&mut A: Vec, i: usize) {
	if A[2*i] >= A[i] {
		A.swap(2*i, i);
		heapify(A, 2*i)
	} else if A[2*i + 1] >= A[i] {
		A.swap(2*i + 1, i);
		heapify(A, 2*i + 1)
	}
}
```

Repeatedly heapifying an array from middle to beginning converts it to a heap.

```rust
fn build_heap(A: Vec) {
	let n = A.len()
	for i in (n/2).floor()..0 {	// this is technically not valid but it's much clearer
		heapify(A, i);
	}
}
```

### Heapsort

Heapsort constructs a heap annd then does magic things that I really cannot be bothered to figure out right now.

```rust
fn heapsort(A: Vec) {
	build_heap(A);
	let n = A.len();
	for i in n..0 {
		A.swap(1, i);
		heapify(A, 1);	// NOTE: heapify takes into account the changed value of n
	}
}
```

### Priority queues

A priority queue is a heap with the property that it can remove the highest value in $O(\log n)$ time.

```rust
fn pop(A: Vec, &n: usize) {
	let biggest = A[0];
	
	A[0] = n;
	*n -= 1;
	heapify(A, 1);
	return biggest;
}
```

```rust
fn insert(A: Vec, &n: usize, key: i32) {
	*n += 1;
	
	let i = n;
	while i > 1 && A[parent(i)] < key {
		A[i] = A[parent(i)];
		i = parent(i);
	}
	A[i] = k;
}
```