linked list implementation mr. mubashir ali · 3. linked-lists •this organization rids us from...

Linked List Implementation

Mr. Mubashir AliLecturer (Dept. of Software Engineering)

[email protected] Garrison University, Lahore

1

Lecture 04

mailto:[email protected]

Previous Lecture

• Abstract List or List ADT

• Arrays

• Passing Arrays to Functions

• Searching Arrays: Linear VS Binary Search

• Lab Work

• 1st Submission

Mubashir Ali - Lecturer (Department of Software Engineering)

2

Outline

1. Disadvantages of Physically Linear DataStructures

2. Treasure Hunt for Kids

3. Linked List

4. Traversal and Implementation

5. Array Based Implementation


3

1. Disadvantages of Physically Linear Data Structures

• Fixed size

• Not flexible

• Insertion / deletion is difficult

• Always need boundary conditions

• etc


4

Continued…

• Given an ordered-list:

– What happens when we add an element to the list?

– What happens when we delete an element from the list?

• In the array implementation, such cases require heavydata movement which is very costly.

• When we deal with linear or ordered-lists, it is in generally notrequired to have a random access to the elements. e.g., weusually don’t need to ask questions like: what is the 8thelement in the list?

• In most cases, the data is processed in a strictly sequentialorder.

• Therefore all that is required is the access to next element.


5

Continued…

• In our previous mapping, the next element happensto be the element at the next index in the array.

• If we can some how tell where the next element isstored, we can eliminate this restriction of placingthe next element at the next physical location!

• This gives rise to the notion of logical adjacency asopposed to physical adjacency.


6

Continued…

• In that case, in order to access the elements ofthe list, all we need is a starting point and somemechanism to from one element to the next.

• In other words, we need a starting point anda link form one element to the next.


7

2. Treasure Hunt for Kids

In a party, clues are made up and scattered allover the house. Kids are divided into teams of 1to 4, depending on how many are at the party.Each clue leads to the next and at the end of thetrail is a treasure for the team, for example,chocolates, toys, etc.


8

Continued…

• In that case, in order to access the elements ofthe list, all we need is a starting point and somemechanism to from one element to the next.

• In other words, we need a starting point and alink from one element to the next.

• We can only travel in the direction of the link.• We have a chain like structure and we can access

the elements in the chain by just following thelinks in the chain.

• Such an organization is known as a linked-list.


9

3. Linked-lists

• This organization rids us from the requirement tomaintaining the logical as well as physical adjacency.

• Now all we need to maintain is the logical sequences andtwo logically adjacent elements need to not bephysically next to each other.

A linked list is a series of connected nodes

Each node contains at least

A piece of data (any type)

Pointer to the next node in the listHead: pointer to the first node

The last node points to NULL


10

Key questions

• How do we represent a position in the list ?

• How do we iterate over the elements of a list ?


11

Implementation

• We can implement this organization by storing the information and handle to the next element with the other data as follows:-

struct element {

handle next; // handle to next list element

data_type data;

};

handle head; // starting point - handle to first list element

head = // initialize head to - the end marker


12

Linked-List Traversal

void traverse (handle head)

{

handle current = head;

while ( current != ) {

process data at current;

current = next field of current element

}

}


13

Add an Element after current element


14


15

Fragile, Handle Links With Care

• If one link is broken, you loose access to all subsequent elements.

• What happens if you swap the following two lines in add:

next field of new element = next field of current; //step 2

next field of current = new_element; //step 3

• to

next field of current = new_element; //step 2

next field of new element = next field of current; //step 3


16


17

Delete an Element After Current Element

void delete (handle current)

{

handle temp = next field of current;

next field of current = next filed of next element

of current

// same as next field of

temp

discard temp

}


18

Delete an Element After Current Element


19

Garbage

• When all access paths to a data object are destroyedbut the data object continues to exist, the dataobject is said to be garbage.

• Garbage is a less serious but still troublesomeproblem. A data object that has become garbage tiesup storage that might otherwise be reallocated foranother purpose.

• A buildup of garbage can force the program toterminate prematurely because of lack of availablefree storage.


20

Garbage


21

Array Based Implementation

• Handle is the index of the next element in the array

struct node {

element_type data;// data

int next;// pointer to the next

} ;


22


class List {private:

int head;int available;int size;node * NodeList;

public:List (int s = 10); // constructor - default size =

10~List( ) { delete [ ] NodeList; } // destructorvoid processList();int search (int data);bool add (int data); // add in ascending ordervoid remove (int data); // delete node from the list

}


23


List::List(int s)

{

if (s <= 0) size = 10; else size = s;

nodeList = new node [size]; // create array

for (int i = 0; i < size-1; i++) // initialize

nodeList[i].next = i+1; // points to the next

nodeList [size-1].next = -1; // last node – there is no next

available = 0;

head = -1; // -1 is used as

}


24

index 0 1 2 3 4 5 6 7 8 9

next 1 2 3 4 5 6 7 8 9 -1 available = 0

data - - - - - - - - - - head = -1


25


26

Initial state (available = 0, head = -1)

index 0 1 2 3 4 5 6 7 8 9

next 1 2 3 4 5 6 7 8 9 -1

data - - - - - - - - - -

Add 5 (available = 1, head = 0)

index 0 1 2 3 4 5 6 7 8 9

next -1 2 3 4 5 6 7 8 9 -1

data 5 - - - - - - - - -


27


index 0 1 2 3 4 5 6 7 8 9

next 1 -1 3 4 5 6 7 8 9 -1

data 5 7 - - - - - - - -


index 0 1 2 3 4 5 6 7 8 9

next 1 2 -1 4 5 6 7 8 9 -1

data 5 7 8 - - - - - - -


28


index 0 1 2 3 4 5 6 7 8 9

next 3 2 -1 1 5 6 7 8 9 -1

data 5 7 8 6 - - - - - -


index 0 1 2 3 4 5 6 7 8 9

next 3 2 -1 1 0 6 7 8 9 -1

data 5 7 8 6 2 - - - - -


29


index 0 1 2 3 4 5 6 7 8 9

next 3 5 -1 2 0 6 7 8 9 -1

data 5 - 8 6 2 - - - - -


index 0 1 2 3 4 5 6 7 8 9

next 3 0 -1 2 1 6 7 8 9 -1

data 5 4 8 6 2 - - - - -


30


31

Delete 2 (available = 4, head = 1)

index 0 1 2 3 4 5 6 7 8 9

next 3 0 -1 2 5 6 7 8 9 -1

data 5 4 8 6 - - - - - -

Delete 8 (available = 2, head = 1)

index 0 1 2 3 4 5 6 7 8 9

next 3 0 4 -1 5 6 7 8 9 -1

data 5 4 - 6 - - - - - -

Summary

Disadvantages of Physically Linear DataStructures

Treasure Hunt for Kids

Linked List

Traversal and Implementation



32

References

you will be able to find course resources at

http://www.mubashirali.com/data-structures-algorithms/


33

http://www.mubashirali.com/data-structures-algorithms/

linked list implementation mr. mubashir ali · 3. linked-lists •this organization rids us from...

Documents