0% found this document useful (0 votes)
22 views41 pages

BIT 2319 Lecture 1 - Review of Data Structures and Algorithms

Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
22 views41 pages

BIT 2319 Lecture 1 - Review of Data Structures and Algorithms

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

BIT 2319 Lecture 1:

Review of Data Structures


Philip Apodo Oyier
[email protected]
Goals of the Course
Become familiar with some of the
fundamental data structures in computer
science
Improve ability to solve problems abstractly
Data structures are the building blocks
Improve ability to analyze your algorithms
Prove correctness
Gauge (and improve) time complexity
Become modestly skilled with the
C/C++/Java programming

2
Observation
All programs manipulate data
Programs process, store, display, gather
Data can be information, numbers,
images, sound
Each program must decide how to store
data
Choice influences program at every level
Execution speed
Memory requirements
Maintenance (debugging, extending, etc.)

3
Data Structures
Data structure is
representation of the logical
relationship existing between
individual elements of data.
 The logical or mathematical
model of a particular
organization of data is called
a data structure.
A data structure is a way of
organizing all data items that
considers not only the
elements stored but also their
relationship to each other.

4
Data Structures Contd.
A data structure is defined by
(1) The logical arrangement of data
elements, combined with
(2) The set of operations we need to
access the elements.
Atomic Variables
Atomic variables can only store one value
at a time.
int num; float s;
A value stored in an atomic variable
cannot be subdivided.
5
What is Algorithm?
Algorithm:
A computable set of steps to achieve a
desired result
Relationship to Data Structure
Example: Find an element
2 4 6
1 3 5 7

1 2 3 4 5 6 7

6
What is it all about?
Solving problems
Get me from home to work
Balance my checkbook
Simulate a jet engine
Graduate from JKUAT
Using a computer to help solve problems
Designing programs (architecture,
algorithms)
Writing programs
Verifying programs
Documenting programs
7
Basic Data Types – the
Simplest Data Structure
Basic data types a language supports:
Integer, float, double, char, boolean
string: usually an array of char supported with
library
A single datum in one of the basic types
A structure is a combination of the basic types
A Publication: code—string, description—string,
price– double
A structure is a combination of basic types and
structures
An Order item: publication—Publication, quantity–
integer, deleteFlag – boolean
8
Storage Container
For storing multiple occurrences of a
structure
Contiguous structures:
Array – supported by a language but
needs care of array size, overflow
Vector – a structure to allow handling of its
size and overflow “automatically”
Linked List: allow data connected by “links”
to save space which may be wasted in an
array/vector.
Combination of vector and linked list
9
Examples of Storage
Containers

10
Notes on the Basic Storage
Containers
Vector and list allow data to be stored in
different ways but not restricted to any
order, or any operations, e.g.,
Data can be ordered in any sequence,
even though searching may prefer a
sorted one.
Operations support inserting an
element in between elements of a
vector, even though it may involve a
lot of “shift” operations.
11
Data Structures and
Algorithms
Algorithm
Outline, the essence of a computational
procedure, step-by-step instructions
A high level, language independent description
of a step-by-step process for solving a problem
Program
An implementation of an algorithm in some
programming language
Data structure
Organization of data needed to solve the
problem
A set of algorithms which implement an ADT

12
Why so many Data
Structures?
Ideal data structure: Dictionary ADT
fast, elegant, memory list
efficient binary search
Generates tensions:
time vs. space
tree
performance vs. AVL tree
elegance Splay tree
generality vs. Red-Black tree
simplicity hash table
one operation’s
performance vs.
another’s
13
Code Implementation
Theoretically
Abstract base class describes ADT
Inherited implementations implement data
structures
Can change data structures transparently (to
client code)
Practice
Different implementations sometimes suggest
different interfaces (generality vs. simplicity)
Performance of a data structure may influence
form of client code (time vs. space, one
operation vs. another)

14
ADT Presentation Algorithm
Present an ADT
Motivate with some applications
Repeat until browned entirely through
Develop a data structure for the ADT
Analyze its properties
Efficiency
Correctness
Limitations
Ease of programming
Contrast data structure’s strengths and
weaknesses
Understand when to use each one

15
Algorithm Strategies
There are countless algorithms
Strategies
Greedy
Divide and Conquer
Dynamic Programming
Exhaustive Search

16
Overall Picture
Data Structure and Implementation
Algorithm Design Goals Goals

Correctness Robustness
Adaptability
Efficiency

Reusability

17
Terminology
Abstract Data Type (ADT)
Mathematical description of an object with set
of operations on the object. Useful building
block.
Algorithm
A high level, language independent,
description of a step-by-step process
Data structure
A specific family of algorithms for
implementing an abstract data type.
Implementation of data structure
A specific implementation in a specific
language
18
Algorithmic Problem
Specificati
Specificati ? on of
on of input output as a
function of
input
Infinite number of input instances satisfying the
specification.
For example:
A sorted, non-decreasing sequence of natural
numbers. The sequence is of non-zero, finite length:
1, 20, 908, 909, 100000, 1000000000.
3.
19
Algorithmic Solution

Input Algorithm Output


instance, related to
adhering to the input
the as required
specification

Algorithm describes actions on the input


instance
Infinitely many correct algorithms for the
same algorithmic problem
20
Algorithm Analysis: Why?
Correctness:
Does the algorithm do what is
intended.
Performance:
What is the running time of the
algorithm.
How much storage does it consume.
Different algorithms may correctly solve
a given task
Which should I use?

21
Example: Sorting
INPUT OUTPUT
sequence of numbers a permutation of the
sequence of numbers

a1, a2, a3,….,an b1,b2,b3,….,bn


Sort
2 5 4 10 7 2 4 5 7 10

Correctness
Correctness Running
Runningtime
time
For
Forany
anygiven
giveninput
inputthethealgorithm
algorithm Depends
Dependson on
halts
haltswith
withthetheoutput:
output: ••number
numberof ofelements
elements(n)(n)
••bb1 <<bb2 <<bb3 <<…. ….<< bbnn ••how
how(partially)
(partially)sorted
sorted
1 2 3
••bb1,,bb2,,bb3,,…., bn is a they
theyare
are
1 2 3 …., bn is a
••algorithm
algorithm
22 permutation
permutationof ofaa11,,aa22,,aa33,….,a
,….,ann
Analysis of Algorithms
Efficiency:
Running time
Space used
Efficiency as a function of input size:
Number of data elements (numbers,
points)
A number of bits in an input number

23
Linear Data Structures
A data structure is said to be linear if its elements
form a sequence or a linear list.
Arrays
Linked Lists
Stacks, Queues
A one:one relationship between elements in the
collection.
Assuming the structure is not empty, there is a first
and a last element.
Every element except the first has a unique
predecessor.
Every element except the last has a unique
successor.
24
General model of a linear
data structure

25
Hierarchical Data Structures
Hierarchical Data Structures
A one:many relationship between
elements in the collection.
Assuming the structure is not empty,
there is a unique element called the
root.
There may be zero to many
terminating nodes called leaves.
Nodes that are neither roots nor
leaves are called internal.
26
General model of a
hierarchical data structure

27
Hierarchical Data Structures
contd.
Every element except the root has a unique
predecessor.
Every element except a leaf has a one or
more successors.
An internal node has exactly one
predecessor and one or more
successors.
There is more than one way to traverse a
hierarchical data structure.
Generally called trees, they are very
important and widely used.
28
Hierarchical Data Structures
contd.
A few types are; Generalized Trees,
Binary Trees, Binary Search Trees, AVL
Trees (balanced binary search trees),
Splay Trees, B Trees, & P Trees.
Similar to linear data types, the basic
structure is the same.
Each version has different rules and
operations.

29
Graph Data Structures
A many:many
relationship between
elements in the
collection.
An element (E) in
graph can be
connected arbitrarily
to any other element
in the graph, (including
itself).
Conversely, any
number of elements
can be connected to E.
30
General model of a graph
Linear Data Structures
Traversal through a liner data structure
is called iteration.
The basic structures are the same.
The operations and restrictions are
different.

31
Operations on Linear Data
Structure
Traversal: Travel through the data structure.
Search: Traversal through the data structure
for a given element.
Insertion: Adding new elements to the data
structure.
Deletion: Removing an element from the
data structure.
Sorting: Arranging the elements in some
type of order.
Merging: Combining two similar data
structures into one.
32
Queue ADT
Queue operations
create
destroy
enqueue dequeue
enqueue
dequeue G FEDCB A
is_empty
Queue property: if x is enQed before y is
enQed, then x will be deQed before y is
deQed
FIFO: First In First Out
33
Applications of the Queue
Hold jobs for a printer
Store packets on network routers
Hold memory “freelists”
Make waitlists fair
Breadth first search

34
LIFO Stack ADT
Stack operations
create A EDCBA
destroy
push B
pop C
top D
is_empty E
Stack property: if x is F F before y is
on the stack
pushed, then x will be popped after y is
popped
LIFO: Last In First Out
35
Stacks in Practice
Function call stack
Removing recursion
Balancing symbols (parentheses)
Evaluating Reverse Polish Notation
Depth first search

36
Array Stack Data Structure
0 S size - 1
f e d c b

back

void push(Object x) {
assert(!is_full()) Object pop() {
S[back] = x back--
back++ return S[back]
}
Object top() {
}
assert(!is_empty()) bool is_full() {
return S[back - 1] return back == size
}
}
37
Linked List Stack Data
Structure
b c d e f

back

void push(Object x) {
temp = back
Object pop() {
back = new Node(x) assert(!is_empty())
back->next = temp return_data = back->data
}
temp = back
Object top() {
assert(!is_empty()) back = back->next
return back->data return return_data
}
}

38
Data Structures you should
already know
Arrays
Linked lists
Trees
Queues
Stacks

39
Proof by Induction
Basis Step:
The algorithm is correct for the base
case (e.g. n=0) by inspection.
Inductive Hypothesis (n=k):
Assume that the algorithm works
correctly for the first k cases, for any k.
Inductive Step (n=k+1):
Given the hypothesis above, show that
the k+1 case will be calculated
correctly.

40
Program Correctness by
Induction
Basis Step: sum(v,0) = 0. 
Inductive Hypothesis (n=k):
Assume sum(v,k) correctly returns
sum of first k elements of v, i.e.
v[0]+v[1]+…+v[k-1]
Inductive Step (n=k+1):
sum(v,n) returns v[k]+sum(v,k)
which is the sum of first k+1 elements
of v. 

41

You might also like