ENGR24524D ALGORITHMS AND DATA
STRUCTURES
,
Nazrul Khan PhD, PEng.
1
Data Structures
Data and Structure:
- Data: Collection of values, numbers, measurements, etc.,
- Structure: A set of rules that holds data together
Data Structure:
- A specific way of storing and organizing data in a
computer for efficient processing
- Provides a means to manage huge amount of data
- Amenable data structures are a key to designing smart
algorithms
- Data structures used are specific to applications
Data Structures
Classifications:
- Linear (arrays, linked lists)
- Nonlinear (trees, graphs)
Linear Data Structure:
- Has a unique element called the first
- Has a unique element called the last
- All the elements except the last has a successor
- All the elements except the first has a predecessor
Data Structures
Linear Data Structure: Representation
- Through sequential memory locations (arrays)
- Through pointers or links (linked lists)
Arrays:
- Data is often available in tabular form
- Arrays are used to represent tabular data
- Matrix represents tabular date and can be represented
as a 2-dimensional array!
Data Structures
Arrays: Properties
- All elements of the array of the same type (int, double)
- Array is a random access data structure
- It is a static data structure. Once defined, can’t be
changed
- Access time for an array element is constant ( O(1))
- Array is perfect when fewer number of
insertions/deletions are required
- Array is suitable when lots of searching, and retrieval are
required.
Data Structures
Arrays: Parameters
- Base Address (b): The memory address of the first byte
of the first array element
- Component Length (L): The memory byte(s) required to
store one element of an array
- Upper and Lower Bounds (li, ui): Each index type has a
smallest and a largest value
- Dimension
Data Structures
Arrays: Representation in Memory
Array Mapping Function (AMF):
- AMF converts index value to element address
Linear (1 D) Arrays:
a: array [l1 .. u1] of element_type
Then addr (a[ i ]) = b +(i – l1) × L
= C0 + C1 × i
Therefore, the time for calculating the address of an
element is same for any value of i.
Data Structures
Arrays: Representation in Memory
Array Mapping Function (AMF):
- AMF converts index value to element address
2D Arrays:
a: array [l1 .. u1 , l2.. u2] of element_type
Order of the elements:
- Row major order
- Column major order
Data Structures
Arrays: Representation in Memory
Data Structures
Arrays: Representation in Memory
Data Structures
Arrays: Representation in Memory
Data Structures
Arrays: Representation in Memory
Data Structures
Arrays: Representation in Memory
Data Structures
Abstract Data Structure:
- Relation: explicit linear ordering
- Operations
- Implementations
Linked lists
Arrays
- Memory requirements
Data Structures
Abstract Data Structure:
- An Abstract List (List ADT) is linearly ordered data
where the programmer explicitly defines the
ordering
- Most Common Operations
The most obvious implementation is to use either
an array or linked list
These are, however, not always the most optimal
Data Structures
Abstract Data Structure: Operations
Data Structures
Abstract Data Structure: Operations
Data Structures
Array: Operations (Shuffling)
Code Snippet
Data Structures
Array: Operations (Shifting)
Code Snippet
Data Structures
Array Lists
- While collecting inputs, we don’t have idea how
many?
- In that case, an array list could be a solution:
Array Lists can grow and shrink as needed
Operations such as inserting/removing could be handy
Data Structures
Array Lists
- How to declare and use?
ArrayList <String> myfriends = new ArrayList<String>();
[Link](“John”);
An array list
String myfriend = [Link](i); object of size 0
[Link](i, Garry);
i is >=0 and <
Get() and [Link] Add() appends
set() used an element to
for the list,
accessing increasing
the its size
element
Data Structures
Array Lists
[Link](“Georgre”);
[Link](“Mustaque”);
[Link](“Robi”); String name =
[Link](2);?
myFriends
George
Mustaque
Robi
Data Structures
Array Lists
[Link](1, “John”);
[Link](1);
Draw the
arrayList
(myFriends)
Data Structures
Array Lists
- There is no ArrayList<int> or ArrayList<double> (primitive data
types!)
- But way out, using Wrapper class!
- Example:
- ArrayList<Double> myValues = new ArrayList<Double>;
[Link](275.135);
double valueVar = [Link](0);
Data Structures
Array and Array Lists
- Array Lists can grow and shrink
- Arrays have nicer syntax for element access and initialization
- If the size of a collection never changes, use an array
- If the collection involves huge primitive data and efficiency is
a concern, array is the choice
- Otherwise, use an array list.
Code Snippet
Data Structures
Linked Lists
Data Structures
Linked Lists
- Linear collection of data elements (nodes) using
pointers
- Having two parts
Information field
Link field (next pointer field), contains the address
of the next node in the list
Data Structures
Linked Lists: Basic Operation
- Insert: Add a new node at the beginning, end or in
between
- Delete: Delete a node from the beginning, end or in
between of the list
- Search: Search a node having particular value (key)
in the linked list
Data Structures
Basic Operation: Insertion
- Add a node at the beginning, end or in-between of a
linked list
Data Structures
Insertion: At the beginning
- Construct a new node that is pointed to by pointer newitem
- We have a global variable head which points to the first node
in the linked list
- The new node points to the first node in the list. The head is
then set to point to the new node
Data Structures
Insertion: At the beginning
- Step 1: Construct a new node that is pointed to by pointer
newItem
- Step 2: Link the new node to the first node of the linked list
- Step 3: Set the pointer head to the new node
Data Structures
Insertion: At the beginning(code snippet)
Data Structures
Insertion: At the end
- Construct a new node and set its link field to “NULL”
- Locate the last node and change its link field to
point to the new node
Data Structures
Insertion: At the end
- Create the new node
- Set a temporary pointer prev to point to the last node
- Set prev to point to the new node and new node as the last
node
Data Structures
Insertion: At the end (code snippet)
Data Structures
Printing List (code snippet)
Data Structures
Linked List: Deletion
- At the beginning of the linked list
- At the end of the linked list
- Within the linked list
Data Structures
Deletion: At the beginning
- Advance the pointer head to the second node
- Release the memory occupied by the abandoned
node
Data Structures
Deletion: At the beginning
- Step1: Initialize the pointer cur point to the first node of the list
- Step 2:Move the pointer head to the second node of the list
- Step 3: Remove the node that is pointed by the pointer cur
Data Structures
Deletion: At the beginning (code snippet)
Data Structures
Deletion: At the end
- Use a local variable, cur
- Cur points to the last node
- Use another variable prev, that points to the second last node
in the linked list
Data Structures
Deletion: At the end
- Step 1: Initialize pointer cur to point to the first node (Head), while
prev points to NULL
- Step 2: Traverse the entire list until cur points to last node (Tail)
- Step 3: Set NULL to next field of the node pointed to by prev
- Step 4: Remove the last node that is pointed to by cur
Data Structures
Deletion: At the end (code snippet)
Data Structures
Deletion: Any
- To delete a node that holds a particular value x in a
linked list, we use
A pointer cur to point to this node and
Another pointer, prev, to point to the previous node
Data Structures
Deletion: Any
- Step 1: Initialize pointer cur to point to the first node (Head),
while pointer prev points to NULL
- Step 2: Traverse the entire list until pointer cur points to node
that contains value x, and prev points to the previous node
Data Structures
Deletion: Any
- Step 3: link the node pointed to by pointer prev to the node
after the cur’s node
- Step 4: Remove the node pointed to by cur
Data Structures
Deletion: Any (code snippet)
Data Structures
Doubly Linked List:
- In linear linked list, we can only traverse in one
direction
- It is desirable to traverse a linked list in both
direction (forward/backward)
- As such, each node must contain two link fields,
instead of one
- One link to denote the predecessor node (left link)
- One link to denote the successor (right link)
Data Structures
Doubly Linked List: Graphical presentation
Data Structures
Doubly Linked List: Basic Operations
- Insert: Add a new node at the beginning, end or in-
between
- Delete: Delete a node from the beginning, end or
from in-between
- Search: Search a node containing a particular value
(key) in the doubly linked list
Data Structures
Basic Operations: Insertion
- Adding a new node, at the beginning, end, or in
between of the linked list
- To add a new node to the head or tail of a doubly
linked list is same steps as linear linked list
- Construct a new node that is pointed to by pointer
newItem
- newItem is linked to the left-most node (or right-
most) in the list. Finally, the Left (or Right) is set to
point to the new node.
Data Structures
Basic Operations: Insertion
- Step 1: Create a new node that is pointed to by
newItem
- Step 2: Set the pointer prev to point to the left node
of the node pointed to by cur
- Step 3: Set the left link of the new node to point to
the node pointed to by prev, and the right link of the
new node to point to the node pointed to by cur
- Step 4: Set the right link of the node pointed to by
prev and the left link of the node pointed to by cur to
point to the new node.
Data Structures
Basic Operations: Insertion (Graphical)
Data Structures
Insertion (beginning): Code snippet
Data Structures
Insertion (end) : Code snippet
Data Structures
Insertion (Middle) : Code snippet
Data Structures
Basic Operations: Deletion
- Process of removing a node from a list. It can take
place- at the beginning, end, and in-between.
- In a single linked list, we have to search and find
the predecessor of the discarded node. But in the
doubly linked list, no search is required
- Given the address of the node that is to be deleted,
the predecessor and the successor nodes are
immediately known.
Data Structures
Basic Operations: Deletion
- Step 1: Set pointer prev to point to the left node of old and
pointer cur to point to the node on the right of old
- Step 2: Set the right link of prev to cur, and the left link of cur
to prev
- Step 3: Discard the node pointed to by old
Data Structures
Java Implementation: Node
- A class that implements a node holds a list element and a successor link.
- This type of data structure is called self-referential or recursive data structure
// A node for a list of string elements:
class Node
{
String element; // list element (DATA)
Node next; // successor link
Node(String el, Node n) // Node placed in
//front of n
{
element = el;
next = n;
}
Node(String el) // Node added without
//link
{
element = el;
next = null;
}
}
Data Structures
Java Implementation: Creation of Linked Lists
Data Structures
Java Implementation: Inserting Node
Data Structures
Java Implementation: Removing Node
Acknowledgements
The above slides are adopted from:
1. Dr. Abul Kashem@buet
2. Douglas Wilhelm Harder@uwaterloo
3. Tony & Godfrey@Mohawk
