Scribd
Upload
9 views192 pages

Data Structures Slides

The document provides an overview of various data structures including queues, stacks, arrays, linked lists, trees, and hash tables, along with their implementations in C. It discusses the concepts of FIFO and LIFO, as well as operations like enqueue, dequeue, push, and pop. Additionally, it covers time complexities for different operations and includes examples of binary search trees and tries.

Uploaded by

inezaodon1
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
9 views192 pages

Data Structures Slides

The document provides an overview of various data structures including queues, stacks, arrays, linked lists, trees, and hash tables, along with their implementations in C. It discusses the concepts of FIFO and LIFO, as well as operations like enqueue, dequeue, push, and pop. Additionally, it covers time complexities for different operations and includes examples of binary search trees and tries.

Uploaded by

inezaodon1
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 192

data structures

abstract data types


queues
FIFO
enqueue

dequeue
const int CAPACITY = 50;

typedef struct
{
person people[CAPACITY];
int size;
} queue;
stacks
LIFO
push

pop
const int CAPACITY = 50;

typedef struct
{
person people[CAPACITY];
int size;
} stack;
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
1 2 3 4
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
0x123

0x456 2
0x456

0x123 0x789 3
0x789

NULL
1
2
3
typedef struct
{
char *name;
char *number;
} 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;
node *list;

list
node *list = NULL;

list
node *list = NULL;

list
node *n = malloc(sizeof(node));

list
node *n = malloc(sizeof(node));

list

n
node *n = malloc(sizeof(node));

list

number

n
next
node *n = malloc(sizeof(node));

list

number

n
next
(*n).number = 1;

list

number

n
next
(*n).number = 1;

list

1 number

n
next
n->number = 1;

list

1 number

n
next
n->next = NULL;

list

1 number

n
next
n->next = NULL;

list

1 number

n
next
list = n;

list

1 number

n
next
list = n;

list

1 number

n
next
list

1
node *n = malloc(sizeof(node));

list

1
node *n = malloc(sizeof(node));

list

1
n
node *n = malloc(sizeof(node));

list

1
n
node *n = malloc(sizeof(node));

list

1
n
n->number = 2;

list

1
n
n->number = 2;

list
2

1
n
n->next = NULL;

list
2

1
n
n->next = NULL;

list
2

1
n
list
2

1
n
list = n;

list
2

1
n
list = n;

list
2

1
n
list = n;

list
2

1
n
list
2

1
n
n->next = list;

list
2

1
n
n->next = list;

list
2

1
n
list = n;

list
2

1
n
list = n;

list
2

1
n
list
2

1
list
2

3 1
ptr

list
2

3 1
ptr

list
2

3 1
ptr

list
2

3 1
ptr

list
2

3 1
list
2

3 1
O(n2)

O(n log n)

O(n)

O(log n)

O(1)
list
list

1
list
2

1
list
2

3 1
O(n2)

O(n log n)

O(n)

O(log n)

O(1)
O(n2)

O(n log n)

O(n)

O(log n)

O(1)
list
list
1
2
list
1
2
list
1
3
O(n2)

O(n log n)

O(n)

O(log n)

O(1)
list
list
2
list
2

1
4
list
2

1
4
list
2

1 3
O(n2)

O(n log n)

O(n)

O(log n)

O(1)
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
2

1
2

1 3
1
1

2
1

3
O(n2)

O(n log n)

O(n)

O(log n)

O(1)
dictionaries
word definition
key value
name number
O(n)

time to solve

O(log n)

size of problem
O(n)

time to solve

O(log n)

O(1)
size of problem
hashing
hash function
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
Mario
Luigi
Mario
Luigi
Mario

Peach
Birdo

Daisy

Goomba

Isabelle

King Boo
Luigi
Mario

Peach

Rosalina
Shy Guy
Toad

Wario

Yoshi
Zelda
Birdo

Daisy

Goomba

Isabelle

King Boo
Luigi Lakitu
Mario

Peach

Rosalina
Shy Guy
Toad

Wario

Yoshi
Zelda
Birdo

Daisy

Goomba

Isabelle

King Boo
Luigi Lakitu Link
Mario

Peach

Rosalina
Shy Guy
Toad

Wario

Yoshi
Zelda
Birdo Bowser Bowser Jr.

Daisy Donkey Kong Diddy Kong Dry Bones

Goomba Ganon

Isabelle

King Boo K.K. Slider


Luigi Lakitu Link
Mario

Peach Petey Piranha

Rosalina
Shy Guy Spike
Toad Toadette Tom Nook

Wario Waluigi

Yoshi
Zelda
O(n2)

O(n log n)

O(n)

O(log n)

O(1)
O(n2)

O(n log n)

O(n)

O(log n)

O(1)
typedef struct
{
char *name;
char *number;
} person;
typedef struct node
{
char *name;
char *number;
struct node *next;
} node;
node *table[26];
input → → output
hash function
Mario → → 12
Luigi → → 11
Laa
Lab
Lac
Lad
Lae
Laf
Lag
Lah
Lai
Laj
Lak Lakitu
...
Lim
Lin Link
Lio
...
Luh
Lui Luigi
Luj
#include <ctype.h>

int hash(char *word)


{
return toupper(word[0]) - 'A';
}
#include <ctype.h>

int hash(const char *word)


{
return toupper(word[0]) - 'A';
}
#include <ctype.h>

unsigned int hash(const char *word)


{
return toupper(word[0]) - 'A';
}
O(n)
O(n/k)
O(n)
O(1)
tries
typedef struct node
{
struct node *children[26];
char *number;
} node;
node *trie;
O(n2)

O(n log n)

O(n)

O(log n)

O(1)

You might also like