JavaTM Education & Technology Services

Data Structures and Algorithms

JavaTM Education & Technology Services

Copyright© Information Technology Institute http://jets.iti.gov.eg 1
 Lists

• Lists:
– Very useful data structure.
– are a way to store many different values under a single variable.
– Every item Node in this list is numbered with an index.
– Unlike counting things that exist in the real world, index variables
always begin with the number 0.

– List Operations:
• Add : add a new node
• Set : update the contents of a node
• Remove: remove a node
• ISEmpty : reports whether the list is empty
• ISFull : reports whether the list is full
• Initialize : create/initialize the list
• Destroy : delete the content of the list.

JavaTM Education & Technology Services

Copyright© Information Technology Institute http://jets.iti.gov.eg 2
 Lists

• Lists Types:
– Array List:
• allocate the memory for all its elements in one block of memory.
• The size of the array is fixed.

Person p;
Person P[10];
Person *p;
// also here you need to know the length early
P= new Person[10];

• The size of the array is fixed.

JavaTM Education & Technology Services

Copyright© Information Technology Institute http://jets.iti.gov.eg 3
 Lists

• Lists Types:
– Array List:
• Given any index , the node with that index can be accessed in constant
time, does not depend on the size of the array.
• Add from the end or insert with shift up process for all other nodes.
• When a node is removed , subsequent nodes must be shifted down, so
removals near the start of the list take longer than removals near the middle
or end.

JavaTM Education & Technology Services

Copyright© Information Technology Institute http://jets.iti.gov.eg 4
 Linked List

JavaTM Education & Technology Services

Copyright© Information Technology Institute http://jets.iti.gov.eg 5
 Linked List

• Purposes of Linked Lists:

– To create arrays of unknown size in memory.

– Linked lists are dynamic, so the length of a list can increase or

decrease as necessary.

– Each node does not necessarily follow the previous one physically in
the memory.

– Linked lists can be maintained in sorted order by inserting or deleting

an element at the proper point in the list.

– To store data in disk-file storage of databases.

• The linked list allows you to insert and delete items quickly and easily
without rearranging- the entire disk file. For these reasons, linked lists are
used extensively in database managers.

JavaTM Education & Technology Services

Copyright© Information Technology Institute http://jets.iti.gov.eg 6
 Linked List

• Type of Linked Lists:

1. Single Linked list:
– A singly linked list contains a link to the next data node.

– Each node contains both its data and pointer to next node in the list.

– Need only one pointer refers to the beginning of the list.

– It is difficult to go back and move through the list.

JavaTM Education & Technology Services

Copyright© Information Technology Institute http://jets.iti.gov.eg 7
 Linked List

• Type of Linked Lists:

2. Doubly-Linked List:
– Contains data and links to both next and the previous node in the list.

– Has pointer to the first node and another for the last node.

– The list can be read in either direction that simplifies sorting the list.

– Because either a forward link or a backward link can read the entire
list, if one link becomes invalid, the list can be reconstructed using the
other link. This is meaningful only in the case of equipment failure.

JavaTM Education & Technology Services

Copyright© Information Technology Institute http://jets.iti.gov.eg 8
 Doubly-Linked List

• Operations of Doubly-Linked List:

– Inserting New Nodes
• Case 1: insert new first node.
• Case 2: insert a new middle node.
• Case 3: insert a new last node.

– Deleting Nodes
• Case 1: delete a node.
• Case 2: deleting all nodes (removing the list).

– Searching for a particular Node.

– Display All

JavaTM Education & Technology Services

Copyright© Information Technology Institute http://jets.iti.gov.eg 9
 Doubly-Linked List

– The following example shows how to build a Doubly-Linked List, using

nodes of Employee Structure.

– Node Element Definition:

class Employee
{
char name[20];
float salary;
float oTime;
int code;
public:
Employee *pNext;
Employee *pPervious;
Employee() { code = o; name=”no name” ; salary = oTime = 0; pNext=NULL; pPrevious =NULL;}
Employee(int c, char *n, float s, float o)
{ code = c; name= n ; salary =s ; oTime =o; pNext=NULL; pPrevious =NULL;}
// setters and getters.
void printEmployee();
};

JavaTM Education & Technology Services

Copyright© Information Technology Institute http://jets.iti.gov.eg 10
 Doubly-Linked List

– List Definition:

class LinkedList
{
protected:
Employee *pStart;
Employee *pEnd;
public:
LinkedList() {pStart=pEnd=NULL;}
~LinkedList() { freeList();}
// Setters and getters for pStart and pEnd;
void addList(Employee *pItem);
void InsertList(Employee *pItem);
Employee* searchList(int Code)
int DeleteList(int Code);
void freeList();
void displayAll();
~LinkedList() { freeList();}
};

JavaTM Education & Technology Services

Copyright© Information Technology Institute http://jets.iti.gov.eg 11
 Doubly-Linked List Operations

– Adding New Nodes

• Case 1: insert new first node.
• Case 2: insert a new last node.
the addList() function in class LinkedList builds a doubly linked list. This
function places each new node on the end of the list (i.e., append the
node to the end of the list).

JavaTM Education & Technology Services

Copyright© Information Technology Institute http://jets.iti.gov.eg 12
 Doubly-Linked List Operations

– Adding New Nodes

JavaTM Education & Technology Services

Copyright© Information Technology Institute http://jets.iti.gov.eg 13
 Doubly-Linked List Operations

– Adding New Nodes

void LinkedList :: addList(Employee *pItem){

if (!pStart) /* Case of empty list Add the first node */
{
pItem->pNext = NULL;
pItem->pPrevious = NULL;
pStart = pEnd = pItem;
}
else /* Case of existing list nodes Append Node */
{
pEnd->pNext = pItem;
pItem->pPrevious = pEnd;
pItem->pNext = NULL;
pEnd = pItem;
}
}

JavaTM Education & Technology Services

Copyright© Information Technology Institute http://jets.iti.gov.eg 14
 Doubly-Linked List Operations

– Searching for a specified Node in the list

Employee* LinkedList :: searchList(int key) // sequential search

{
Employee * pItem= NULL;
pItem = pStart; // begin from the first node
while(pItem && pItem->getCode() != key)
{
pItem = pItem->pNext;
}
return pItem;
}

JavaTM Education & Technology Services

Copyright© Information Technology Institute http://jets.iti.gov.eg 15
 Doubly-Linked List Operations

– Display All

void LinkedList :: displayAll(){

Employee * pItem;
pItem = pStart;
while(pItem)
{
pltem->printEmployee();
pltem = pltem ->pNext;
}
}

JavaTM Education & Technology Services

Copyright© Information Technology Institute http://jets.iti.gov.eg 16
 Doubly-Linked List Operations

– Deleting a Node from the List

• Case 1: Deleting the first node.
• Case 2: Deleting a middle node.
• Case 3: Deleting the last node.
• Steps:
1. Search for the node first.
2. No action, if it is not found.
3. Found at the first place.
4. Found at the last place.
5. Found in middle.
6. If it is the only node.

JavaTM Education & Technology Services

Copyright© Information Technology Institute http://jets.iti.gov.eg 17
 Doubly-Linked List Operations

– Deleting a Node from the List

• Case 1: Deleting the first node.

JavaTM Education & Technology Services

Copyright© Information Technology Institute http://jets.iti.gov.eg 18
 Doubly-Linked List Operations

– Deleting a Node from the List

• Case 2: Deleting a middle node.

JavaTM Education & Technology Services

Copyright© Information Technology Institute http://jets.iti.gov.eg 19
 Doubly-Linked List Operations

– Deleting a Node from the List

• Case 3: Deleting the last node.

JavaTM Education & Technology Services

Copyright© Information Technology Institute http://jets.iti.gov.eg 20
 Doubly-Linked List Operations

– Deleting a Node from the List

int LinkedList :: deleteList(int Code){
Employee *pItem;
int RetFlag = 1;
pItem = SearchList(Code); // First search for it
if (!pItem)
{ RetFlag = 0; } //Not found
else
{ // Found
if (pStart == pEnd) /* Case of one node */
{
pStart = pEnd = NULL;
}
else if(pItem == pStart) /* Case of first node */
{
pStart = pStart->pNext;
pStart->pPrevious = NULL;
}
else if(pItem == pEnd) /* Case of last node */
{
pEnd = pEnd->pPrevious;
pEnd->pNext = NULL;
}
JavaTM Education & Technology Services
Copyright© Information Technology Institute http://jets.iti.gov.eg 21
 Doubly-Linked List Operations

– Deleting a Node from the List

else /* Case of intermediate node */

{
pItem->pPrevious->pNext = pItem->pNext;
pItem->pNext->pPrevious = pItem->pPrevious;
}
delete pItem;
}
return RetFlag;
}

JavaTM Education & Technology Services

Copyright© Information Technology Institute http://jets.iti.gov.eg 22
 Doubly-Linked List Operations

– Removing the Entire List

void LinkedList :: freeList(){

Employee * pItem;
while(pStart)
{
pItem = pStart;
pStart = pStart->pNext;
delete pItem;
}
pEnd = NULL;
}

JavaTM Education & Technology Services

Copyright© Information Technology Institute http://jets.iti.gov.eg 23
 Doubly-Linked List Operations

– Inserting a Node to the ordered list Cases

void LinkedList :: insertList(Employee *pNode){
Employee *ptemp;
if(pStart==NULL) addList (pNode); // empty list
else
{
ptemp=pStart;
while(ptemp && ptemp ->getCode() < pNode->getCode() )
ptemp= ptemp->pNext; // find its right location or reach the end
if(!ptemp) addList (pNode); // it will be the last Node
else if(ptemp==pStart) // it will be the first Node
{
pNode->pNext=pStart;
pNode->pPervious=NULL;
pStart->pPervious=pNode;
pStart=pNode;
}
else // in any middle loaction
{
pNode->pNext=ptemp;
pNode->pPervious=ptemp->pPervious;
ptemp->pPervious->pNext=pNode;
ptemp->pPervious=pNode;
}
}
}
JavaTM Education & Technology Services
Copyright© Information Technology Institute http://jets.iti.gov.eg 24
 Lab Exercise

JavaTM Education & Technology Services

Copyright© Information Technology Institute http://jets.iti.gov.eg 25
 Lab Exercise

• 1st Assignment :
1. Implement Doubly Linked list with all operations.
2. Bonus: Sort Doubly Linked List.
3. Search: Implement Circular Doubly Linked Lists operations.

JavaTM Education & Technology Services

Copyright© Information Technology Institute http://jets.iti.gov.eg 26