Download lab#4 Linked Lists - Data Structures CS322

LAB#4
Overview
Before we go to our lesson we must know about :
1. data structure .
2. Algorithms .
data structure is an arrangement of data in a
computer’s memory (or sometimes on a disk). Data
structures include linked lists, arry , stacks, binary
trees, and hash tables.
Algorithms is manipulate the data in these
structures in various ways, such as inserting a new
data item, searching for a particular item, or sorting
the items.
2
Overview of Data Structures
A data structure is an arrangement of data in a
computer’s memory (or sometimes on a disk). Data
structures include linked lists, stacks, binary trees,
and hash tables.
Overview of Algorithms
Algorithms manipulate the data in these structures
in various ways, such as inserting a new data item,
searching for a particular item, or sorting the
items.
3
Arrays: pluses and minuses
+ Fast element access.
-- Impossible to resize.
• Many applications require resizing!
• Required size not always immediately
available.
• All of these problem in array we can fix it
we linked list
Linked Lists
4
Q: What is the meaning of this symbol ->
It mean Accessing Class Members
Through an object of the class using (.)
Through a pointer to the class using (->)
For example:
Student S1;
S1. setstnum(1234);
Student *S1ptr;
Or
(*S1ptr).setstnum(1234);
S1ptr-> setstnum(1234);
Linked List :
A
B
C
0
Tail
Head
• 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 list
• Head: pointer to the first node.
• The last node points to NULL.
node
A
data
pointer
Singly Linked List :
• We use two classes: Node and List
o Declare IntSLLNode class for the nodes
class IntSLLNode
{
public:
IntSLLNode() { next = 0; }
IntSLLNode(int i, IntSLLNode *ptr = 0)
{ info = i;
next = ptr; }
int info;
IntSLLNode *next; };
Singly Linked List :
o Declare IntSLList which contains :
class IntSLList {
public:
IntSLList() {head = tail =0; }
void AddToHead(int);
void AddToTail(int);
void DeleteFromHead();
void DeleteFromTail();
void DeleteNode(int);
bool isInList(int) const;
void DisplayList();
private:
IntSLLNode *head, *tail; };
Inserting at the Head
1. Allocate a new node
2. Insert new element
3. Make new node
point to old head
4. Update head to point
to new node
Linked Lists
9
Singly Linked List :
o Declare IntSLList Class member function:
1- void AddToHead(int);
void IntSLList::AddToHead(int el)
{
head = new IntSLLNode(el,head);
if (tail == 0)
tail = head;
}
Inserting at the Tail
Allocate a new
node
Insert new element
Have new node
point to null
Have old last node
point to new node
Update tail to point
to new node
.1
.2
.3
.4
.5
Linked Lists
11
Singly Linked List :
o Declare IntLList Class member function:
2- void AddToTail(int);
void IntSLList::AddToTail(int el)
{
if (tail != 0) // if list not empty;
{
tail->next = new IntSLLNode(el);
tail = tail->next; }
else
head = tail = new IntSLLNode(el);
}
Removing at the Head
1. Update head to point
to next node in the
list
2. Allow garbage
collector to reclaim
the former first node
Linked Lists
13
Singly Linked List :
o Declare IntLList Class member function:
3- void DeleteFromHead();
void IntSLList::DeleteFromHead(){
if(head !=0)
{
IntSLLNode *tmp =head;
if (head == tail) //if only one node in the list
head = tail = 0;
else head = head ->next;
delete tmp;}
}
Removing at the Tail
• Removing at the tail of
a singly linked list
cannot be efficient!
• There is no constanttime way to update
the tail to point to the
previous node
Linked Lists
15
Singly Linked List :
4- void DeleteFromTail();
void IntSLList::DeleteFromTail()
{if(head != 0)
{if (head == tail) //if only one node in the list
{delete head;
head=tail=0;}
else { IntSLLNode *tmp; //find the predecessor of tail
for(tmp=head; tmp->next != tail; tmp = tmp->next);
delete tail;
tail=tmp;
tail->next=0;}}
}
Singly Linked List :
o Declare IntLList Class member function:
5- int DeleteNode(int el);
Singly Linked List :
o Declare IntLList Class member function:
6- bool isInList(int) const;
bool IntSLList:: isInList(int el) const
{
IntSLLNode *tmp;
for (tmp=head; tmp != 0 && !(tmp->info == el);
tmp = tmp->next);
return tmp !=0;
}
Singly Linked List :
o Declare IntSLList Class member function:
7- void DisplayList();
void IntSLList::DisplayList()
{IntSLLNode *current;
current = head;
cout << "head = " << head << "\n";
while(current != 0)
{cout << current->info << " " << current << "\n";
current=current->next;}
cout << "tail = " << tail << "\n";
cout << "----------------------" << "\n";}
Singly Linked List :
• Using List :
void main()
{IntSLList myllist;
myllist.AddToHead(50);
myllist.AddToHead(90);
myllist.AddToHead(60);
myllist.AddToHead(68);
myllist.DisplayList();
myllist.DeleteFromHead();
myllist.DeleteNode(60);
if (myllist.isInList(60)== 0)
cout<<"60 isn't in the list" << endl;
cout<<"60 is in the list" << endl;
myllist.DisplayList();}
Doubly Linked List
• A doubly linked list is often more
convenient!
• Nodes store:
– element
– link to the previous node
– link to the next node
prev
next
elem
node
• Special trailer and header nodes
nodes/positions
header
trailer
elements
Linked Lists
22
Doubly Linked List :
o Declare IntDLLNode which contains :
class IntDLLNode{
public:
IntDLLNode() {next=prev=0;}
IntDLLNode(int el,IntDLLNode *n=0,IntDLLNode *p=0){
info = el; next=n; prev =p;
}
Int info;
IntDLLNode *next, *prev;
};
Doubly Linked List :
o Declare IntDLList which contains :
class IntDLList{
public:
IntDLList(){
Head=tail=0;}
void addToDLLTail(int el);
void deleteFromDLLTail();
void IntDLList::DisplayFromHead();
protected:
IntDLLNode *head ,*tail;
};
Insertion
• We visualize operation insertAfter(p, X), which returns position q
p
A
B
C
p
A
q
B
C
X
p
A
q
B
Linked Lists
X
C
25
Insertion Algorithm
Algorithm insertAfter(p,e):
Create a new node v
v.setElement(e)
v.setPrev(p) {link v to its predecessor}
v.setNext(p.getNext())
{link v to its successor}
(p.getNext()).setPrev(v) {link p’s old successor to v}
p.setNext(v)
{link p to its new successor, v}
return v
{the position for the element e}
Linked Lists
26
Doubly Linked List :
o Declare IntDLList Class member function:
1- void addToDLLTail(int el);
void IntDLList:: addToDLLTail(int el)
{if (tail!=0){
tail=new IntDLLNode(el,0,tail);
tail->prev->next=tail;}
else
head=tail=new IntDLLNode(el);
}
Deletion
• We visualize remove(p), where p == last()
A
B
C
A
B
C
p
D
p
D
A
B
Linked Lists
C
28
Deletion Algorithm
Algorithm remove(p):
t = p.element
{a temporary variable to hold the
return value}
(p.getPrev()).setNext(p.getNext()) {linking out p}
(p.getNext()).setPrev(p.getPrev())
p.setPrev(null)
{invalidating the position p}
p.setNext(null)
return t
Linked Lists
29
Doubly Linked List :
o Declare IntDLList Class member function:
2- void deleteFromDLLTail()
void IntDLList:: deleteFromDLLTail()
{if(tail !=0){
if(head==tail) { //if only one node in the list
delete head;
head = tail =0;}
else {
tail = tail->prev;
delete tail->next;
tail->next = 0;}}}
Doubly Linked List :
o Declare IntDLList Class member function:
2- void IntDLList::DisplayFromHead();
void IntDLList::DisplayFromHead()
{
IntDLLNode *current;
for( current = head ; current != 0 ; current =
current->next )
cout<<current->info<<endl;
cout<<"--------------------------------"<<endl;
}
Evolution question
• Create empty linked list and then add a new
node with data 50
Answer of Evolution question