This is CS50

arrays
1 2 3
1 2 3
1 2 3
 1 2 3 h e l l
o , w o r l d
\0
1 2 3
1 2 3

1
1 2 3

1 2
1 2 3

1 2 3
1 2 3
1 2 3 4
O(n2)

O(n log n)

O(n)

O(log n)

O(1)
O(n2)

O(n log n)

O(n)

O(log n) search

O(1)
O(n2)

O(n log n)

O(n) insert

O(log n) search

O(1)
Ω(n2)

Ω(n log n)

Ω(n)

Ω(log n)

Ω(1)
data structures
struct

*
struct

->
linked lists
1
0x123
1
0x123

2
0x456
1
0x123

2
0x456

3
0x789
1
0x123

2
0x456

3
0x789
 1
0x123

0x456 2
0x456

3
0x789
 1
0x123

0x456 2
0x456

0x789 3
0x789
 1
0x123

0x456 2
0x456

0x789 3
0x789

0x0
 1
0x123

0x456 2
0x456

0x789 3
0x789

NULL
1
2
3
typedef struct
{
string name;
string number;
}
person;
typedef struct
{

}
person;
typedef struct
{

}
node;
typedef struct
{
int number;

}
node;
typedef struct
{
int number;
node *next;
}
node;
typedef struct node
{
int number;
node *next;
}
node;
typedef struct node
{
int number;
struct node *next;
}
node;
node *list;
list
node *list = NULL;
list
node *n = malloc(sizeof(node));
list

n
if (n != NULL)
{
(*n).number = 1;
}
if (n != NULL)
{
n->number = 1;
}
list
1

n
if (n != NULL)
{
n->next = NULL;
}
list
1

n
list = n;
list
1

n
list
1
node *n = malloc(sizeof(node));
if (n != NULL)
{
n->number = 2;
n->next = NULL;
}
 2
list
1

n
list->next = n;
 2
list
1

n
 2
list
1
node *n = malloc(sizeof(node));
if (n != NULL)
{
n->number = 3;
n->next = NULL;
}
 2
list
1
3

n
list->next->next = n;
 2
list
1
3

n
 2
list
1
3
 4
list
2
5
node *n = malloc(sizeof(node));
if (n != NULL)
{
n->number = 1;
n->next = NULL;
}
 4
list
2
5

1
list = n;
 4
list
2
5

1
n->next = list;
 4
list
2
5

1
list = n;
 4
list
2
5

1
 4
list
2
5

1 3
 4
list
2
5

1 3
 4
list
2
5

1 3
trees
binary search trees
1 2 3 4 5 6 7
1 2 3 4 5 6 7
1 2 3 4 5 6 7
1 2 3 4 5 6 7
 4

2 6

1 3 5 7
 4

2 6

1 3 5 7
typedef struct node
{
int number;
struct node *next;
}
node;
typedef struct node
{
int number;

}
node;
typedef struct node
{
int number;

}
node;
typedef struct node
{
int number;
struct node *left;
struct node *right;
}
node;
 4

2 6

1 3 5 7
bool search(node *tree, int number)
{
if (tree == NULL)
{
return false;
}
else if (number < tree->number)
{
return search(tree->left, number);
}
else if (number > tree->number)
{
return search(tree->right, number);
}
else if (number == tree->number)
{
return true;
}
}
bool search(node *tree, int number)
{
if (tree == NULL)
{
return false;
}
else if (number < tree->number)
{
return search(tree->left, number);
}
else if (number > tree->number)
{
return search(tree->right, number);
}
else if (number == tree->number)
{
return true;
}
}
bool search(node *tree, int number)
{
if (tree == NULL)
{
return false;
}
else if (number < tree->number)
{
return search(tree->left, number);
}
else if (number > tree->number)
{
return search(tree->right, number);
}
else if (number == tree->number)
{
return true;
}
}
bool search(node *tree, int number)
{
if (tree == NULL)
{
return false;
}
else if (number < tree->number)
{
return search(tree->left, number);
}
else if (number > tree->number)
{
return search(tree->right, number);
}
else if (number == tree->number)
{
return true;
}
}
bool search(node *tree, int number)
{
if (tree == NULL)
{
return false;
}
else if (number < tree->number)
{
return search(tree->left, number);
}
else if (number > tree->number)
{
return search(tree->right, number);
}
else if (number == tree->number)
{
return true;
}
}
bool search(node *tree, int number)
{
if (tree == NULL)
{
return false;
}
else if (number < tree->number)
{
return search(tree->left, number);
}
else if (number > tree->number)
{
return search(tree->right, number);
}
else if (number == tree->number)
{
return true;
}
}
 4

2 6

1 3 5 7
 2

1 3
1

3
O(n2)

O(n log n)

O(n)

O(log n)

O(1)
O(n2)

O(n log n)

O(n)

O(log n) search

O(1)
O(n2)

O(n log n)

O(n)

O(log n) search, insert

O(1)
Ω(n2)

Ω(n log n)

Ω(n)

Ω(log n)

Ω(1)
hash tables
 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
Albus
Albus

Zacharias
Albus

Hermione

Zacharias
Albus

Cedric
Draco

Fred
Ginny
Hermione

James
Kingsley
Luna
Minerva
Neville

Petunia

Ron
Severus

Vernon

Zacharias
Albus

Cedric
Draco

Fred
Ginny
Hermione Harry

James
Kingsley
Luna
Minerva
Neville

Petunia

Ron
Severus

Vernon

Zacharias
Albus

Cedric
Draco

Fred
Ginny
Hermione Harry Hagrid

James
Kingsley
Luna
Minerva
Neville

Petunia

Ron
Severus

Vernon

Zacharias
Albus

Cedric
Draco

Fred
Ginny George
Hermione Harry Hagrid

James
Kingsley
Luna Lily Lucius
Minerva
Neville

Petunia

Ron Remus
Severus Sirius

Vernon

Zacharias
input → → output
hash function
Albus → →0
Zacharias → → 25
Albus

Cedric
Draco

Fred
Ginny George
Hermione Harry Hagrid

James
Kingsley
Luna Lily Lucius Lavender
Minerva
Neville

Petunia

Ron Remus
Severus Sirius

Vernon

Zacharias
Hermione Harry Hagrid
A
B
C
D
E
F
G
H Hermione Harry Hagrid
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
H
Ha
Ha
Hb
Hc
Hd
He
Hf
Ha
Hb
Hc
Hd
He Hermione
Hf
Ha Harry
Hb
Hc
Hd
He Hermione
Hf
Ha Harry Hagrid
Hb
Hc
Hd
He Hermione
Hf
Ha
Haa
Haa
Hab
Hac
Had
Hae
Haf
Hag
...
Haq
Har
Has
...
Heq
Her
Hes
Haa
Hab
Hac
Had
Hae
Haf
Hag
...
Haq
Har
Has
...
Heq
Her Hermione
Hes
Haa
Hab
Hac
Had
Hae
Haf
Hag
...
Haq
Har Harry
Has
...
Heq
Her Hermione
Hes
Haa
Hab
Hac
Had
Hae
Haf
Hag Hagrid
...
Haq
Har Harry
Has
...
Heq
Her Hermione
Hes
Albus

Cedric
Draco

Fred
Ginny George
Hermione Harry Hagrid

James
Kingsley
Luna Lily Lucius Lavender
Minerva
Neville

Petunia

Ron Remus
Severus Sirius

Vernon

Zacharias
O(n2)

O(n log n)

O(n)

O(log n)

O(1)
O(n2)

O(n log n)

O(n) search

O(log n)

O(1)
O(n2)

O(n log n)

O(n) search, insert

O(log n)

O(1)
O(n2)

O(n log n)

O(n) search

O(log n)

O(1) insert
Ω(n2)

Ω(n log n)

Ω(n)

Ω(log n)

Ω(1)
tries
O(n2)

O(n log n)

O(n)

O(log n)

O(1)
O(k) search
O(k) search, insert
O(1) search, insert
O(n2)

O(n log n)

O(n)

O(log n)

O(1) search, insert

dequeue
stacks
LIFO
push

pop
dictionaries
This is CS50