Data Structures and

Algorithms
List ADT
An ADT – from the previous lecture

•An abstract data type (ADT) is:

•a collection of data, along with
•A set of operations on that data.
•Data structures specify a way to
organize our data in an ADT
•The operations that are supported by
the ADT are designed using Algorithms
Algorithm

•Typically, we represent the

implementation of an ADT operations by
the use of an algorithm
•An algorithm is a finite sequence of
instructions that specifies precisely how
an operation will be performed
•An algorithm can be expressed by
flowcharts or pseudocode
Pseudocode

• Pseudocode can be used to express algorithms in a

manner independent of a programming language

• Pseudocode is not meant to be compiled or

executed by the computer

• The reason for using pseudocode is to allow the

designer to convey basic ideas about an algorithm
in general terms
Pseudocode (2)

• Pseudocode allows us to represent

algorithms without worrying about
implementation details
• This facilitates the analysis of algorithms

• Pseudocode consists of keywords and

English-like phrases that are indented to
indicate flow of control
 The List ADT
• A list is an ordered set of elements i.e.
L = (l1, l2, …, ln)
• where li is the i-th element of the list
• The elements of the list have a linear ordering based on the position in the
list
• we say li+1 follows (succeeds) li and li-1 precedes li
• The first element in the list l1, is referred to as the head, while the last
element ln is the tail.
• The length of the list is given by |L|.
Defining the List ADT
• What data are required?
• “Items” of a particular data type.
• Let’s define the items to be of type ItemType
What operations are required?
• Create an empty list
• Destroy a list
• Determine the number of items in a list
• Insert an item at a given position in a list
• Remove the item at a given position in a list
• Retrieve the item at a given position in a list
 Formal Definition of Operations
• createList(L). Create an empty list
• makeEmpty(L). Destroy a list L
• insert(L, x, i). Adds element x at position i in the of list L
• Append(L, x). Adds element x to the tail of list L
• retrieve (L, i). Returns the element stored at position i of L or
null if position doesn’t exist
• delete(L, i). deletes the element stored at position i of L.
• this causes element Ii+1….n to become I I ……I
1, i+1 n
• Length of the list becomes Length-1
• length(L). Returns the length of list |L|
 Example
• Consider the List L = (dog, cat,
rat, bat)
1. insert (L, pig, 2)
2. insert (L, cow, 4)
3. append (L, hen)
4. delete (L, rat)
5. retrieve (L, 3)
Implementing a List
• There are two fundamental ways of storing
structures in a computers memory, namely:
1. Sequential storage
• Each element of the structure is stored next to the other.
This is also called array-based implementation
2. Linked storage
• Each element of the structure may be stored anywhere in
memory. This requires that we explicitly store in each
element the address of the next element using a pointer.
Also called pointer implementation
Array-Based List Implementation
• By allocating an array of memory at compile time, we can
create a list of elements.

l1 l2 l3 …. ln ….
List[0] List[1] List[2] List[n]

The structure can be defines as

#define MAXLEN = 100
typedef int itemType;
typedef struct {
itemType List [MAXLEN]; /* array of list items */
int length; /* number of items in the list */
} List;
 Implementing Operations (3)

1.Insertion Operation
•Inserting at the head of the list requires first pushing
the entire array one step to make room for the new
element
a1 a2 a3 a4 …. an

0 1 2 3 n-1

insert(L,0,x)

a1 a2 a3 a4 …. an

0 1 2 3 n-1

x a1 a2 a3 …. an-1 an

0 1 2 3 n-1
Insertion Algorithms

Insert ( L, x, i)

If (i <= 0) or (i > length) then

return “Invalid List position”

// make room for the new item by shifting

// all items at position >= i
for j  length to i increment –1 do
L[j+1]  L[j]

// insert new item

L[i] = x
length  length + 1
 Implementing Operations (4)
2. Deletion Operations
• Deleting the first element requires shifting all the elements in the list up one

Delete (List L, integer i)

If (i <= 0) or (i > length) then
return “Invalid List position”

//delete item by shifting all items at

// positions > i toward the head of the list
for j  i+1 to length do
L[j-1]  L[j]
length  length - 1
 Implementing Operations (1)
3. Retrieve operation
• Retrieval of the i-th element can be implemented in efficiently since each
element can be accessed directly given its position.

Retrieve (List L, integer i)

If (i <= 0) or (i > length) then

return “Invalid List position”
elem  List[i-1] // retrieve the
element
return elem
 Implementing Operations (2)
4. Search Operation
• To find an element k in the list, you compare it with each element of the array

Search (List L, key k)

for i  1 to length do
elem  Retrieve(L,i)
if k = elem then
return i //search
successful
return -1 // search unsuccessful
Advantages and Disadvantages

Advantages of the array-based implementation

•Simple to implement
•Implementing the list operations is very efficient
Disadvantages
•The array structure is static, placing a limitation on the size (specified
at compile time). This
• Can lead to overflow
• Is an inefficient use of space
C Implementation Of Array-
based List
• Lab 1
Linked Implementation

• A linked list consists of a sequence of basic structures (called

nodes). Each node contains two fields

• Data: which holds the elements of the list

• Next: which stores a pointer (link) to the next node in the

list
next
data
Linked List Implementation (2)

• Access to the list is gained through a pointer to the head of the list
(or a header node).
• This structure is called a singly linked list because each node in the
list is connected to the next by a single link.

head

cat rat bat

dog
Node Declaration

• In c++ the node can be declared as:

Class Node
{
Private:
T data;
Node<T<*next;
};
Linked List Declaration

• The list can be declared as

Class SLList{
Private:
Int Lenth;Node * head;//pointer to head
Public:
/specify the list operations
};
List Operations

• Unlike the array-based implementation,

there is no direct access to arbitrary
elements of the list.
• In order to access the i-th element, we must
traverse the list, beginning from the head until
the element is located.
Linked List Traversal

1. To find the address of the i-th element, we can use the following
algorithm
Traverse (integer i)
prev head //pointer to head
current  head //make head the
current
if i ≠ 1 then
current  current->next
for j  2 to i do
prev  current
current  current->next
return prev
2. Insertion Operation

• To insert an element at the position i, we need to

have access to position i-1, then splice the new
node into the list
ii +1
+2
i-1 i i+1

i
Insertion Algorithm
• Inserting after a node
• Suppose that we have a pointer, prev pointing to the node at position i-1
then insert operation can be performed using the following statements

Insert (Node ↑prev, x)

newNode  new Node(x)
newNode->next  prev -
>next
prev->next  newNode
length  length + 1
Exercise

• Write an algorithm for inserting an element

i) at the head of the list

ii) at the tail of the list

2. Deletion Operation

• To delete a data stored in a node at position i, the operation requires

that we modify the next field of the node at position i-1

i +1
i
i-1 i
 Deletion Algorithm

• To delete a node
• We require two pointers, previous that points to the node at position i-1 and
current that points to the i-th node
• The operation can then be accomplished by

Delete (Node ↑previous, Node ↑current

previous->next  current->next
delete current
length  length + 1
Exercise

• Write an algorithm for delete an element

i) at the head of the list
ii) at the tail of the list
Advantages and Disadvantages

• Advantages of the Linked List

Implementation
• Memory is efficiently used, since there is no wasted space
• It is a very flexible data structure and can be used in many
applications, either by itself or as part of a more complicated data
structure
• Disadvantages
• Random access is not possible because to get to a particular node,
we must traverse the list starting from the head.
• Movement along the list is one way.
C Implementation of Linked List

• Lab 2
Other Variations of the Linked List

A singly linked list is time consuming if we want to

move to the end of the list, and/or
move in the reverse direction
The LIST ADT can also be implemented using a
doubly linked list
Circular linked list (singly or doubly)
Doubly Linked List

• In a doubly linked list, each node contains three

fields,
• Data: which holds the elements of the list
• Next: which stores a pointer (link) to the next node
in the list
• Previous: which stores a pointer (link) to the
previous node in the list

data
 Doubly Linked List
L

a3
* a1 a2 a4 *
 Circular Doubly Linked List
L

a3
a1 a2 a4